interact with the Git data structures.
"""
import os, sys, zlib, time, subprocess, struct, stat, re, tempfile, glob
+from collections import namedtuple
+
from bup.helpers import *
from bup import _helpers, path, midx, bloom, xstat
pass
-def repo(sub = ''):
+def parse_tz_offset(s):
+ """UTC offset in seconds."""
+ tz_off = (int(s[1:3]) * 60 * 60) + (int(s[3:5]) * 60)
+ if s[0] == '-':
+ return - tz_off
+ return tz_off
+
+
+# FIXME: derived from http://git.rsbx.net/Documents/Git_Data_Formats.txt
+# Make sure that's authoritative.
+_start_end_char = r'[^ .,:;<>"\'\0\n]'
+_content_char = r'[^\0\n<>]'
+_safe_str_rx = '(?:%s{1,2}|(?:%s%s*%s))' \
+ % (_start_end_char,
+ _start_end_char, _content_char, _start_end_char)
+_tz_rx = r'[-+]\d\d[0-5]\d'
+_parent_rx = r'(?:parent [abcdefABCDEF0123456789]{40}\n)'
+_commit_rx = re.compile(r'''tree (?P<tree>[abcdefABCDEF0123456789]{40})
+(?P<parents>%s*)author (?P<author_name>%s) <(?P<author_mail>%s)> (?P<asec>\d+) (?P<atz>%s)
+committer (?P<committer_name>%s) <(?P<committer_mail>%s)> (?P<csec>\d+) (?P<ctz>%s)
+
+(?P<message>(?:.|\n)*)''' % (_parent_rx,
+ _safe_str_rx, _safe_str_rx, _tz_rx,
+ _safe_str_rx, _safe_str_rx, _tz_rx))
+_parent_hash_rx = re.compile(r'\s*parent ([abcdefABCDEF0123456789]{40})\s*')
+
+
+# Note that the author_sec and committer_sec values are (UTC) epoch seconds.
+CommitInfo = namedtuple('CommitInfo', ['tree', 'parents',
+ 'author_name', 'author_mail',
+ 'author_sec', 'author_offset',
+ 'committer_name', 'committer_mail',
+ 'committer_sec', 'committer_offset',
+ 'message'])
+
+def parse_commit(content):
+ commit_match = re.match(_commit_rx, content)
+ if not commit_match:
+ raise Exception('cannot parse commit %r' % content)
+ matches = commit_match.groupdict()
+ return CommitInfo(tree=matches['tree'],
+ parents=re.findall(_parent_hash_rx, matches['parents']),
+ author_name=matches['author_name'],
+ author_mail=matches['author_mail'],
+ author_sec=int(matches['asec']),
+ author_offset=parse_tz_offset(matches['atz']),
+ committer_name=matches['committer_name'],
+ committer_mail=matches['committer_mail'],
+ committer_sec=int(matches['csec']),
+ committer_offset=parse_tz_offset(matches['ctz']),
+ message=matches['message'])
+
+
+def get_commit_items(id, cp):
+ commit_it = cp.get(id)
+ assert(commit_it.next() == 'commit')
+ commit_content = ''.join(commit_it)
+ return parse_commit(commit_content)
+
+
+def repo(sub = '', repo_dir=None):
"""Get the path to the git repository or one of its subdirectories."""
global repodir
- if not repodir:
+ repo_dir = repo_dir or repodir
+ if not repo_dir:
raise GitError('You should call check_repo_or_die()')
# If there's a .git subdirectory, then the actual repo is in there.
- gd = os.path.join(repodir, '.git')
+ gd = os.path.join(repo_dir, '.git')
if os.path.exists(gd):
repodir = gd
- return os.path.join(repodir, sub)
+ return os.path.join(repo_dir, sub)
def shorten_hash(s):
"""Mangle a file name to present an abstract name for segmented files.
Mangled file names will have the ".bup" extension added to them. If a
file's name already ends with ".bup", a ".bupl" extension is added to
- disambiguate normal files from semgmented ones.
+ disambiguate normal files from segmented ones.
"""
if stat.S_ISREG(mode) and not stat.S_ISREG(gitmode):
+ assert(stat.S_ISDIR(gitmode))
return name + '.bup'
elif name.endswith('.bup') or name[:-1].endswith('.bup'):
return name + '.bupl'
the following:
* BUP_NORMAL : files that should be read as-is from the repository
- * BUP_CHUNKED : files that were chunked and need to be assembled
+ * BUP_CHUNKED : files that were chunked and need to be reassembled
- For more information on the name mangling algorythm, see mangle_name()
+ For more information on the name mangling algorithm, see mangle_name()
"""
if name.endswith('.bupl'):
return (name[:-5], BUP_NORMAL)
' used by %s\n') % (n, mxf))
broken = True
if broken:
+ mx.close()
del mx
unlink(full)
else:
elif not ix.force_keep:
debug1('midx: removing redundant: %s\n'
% os.path.basename(ix.name))
+ ix.close()
unlink(ix.name)
for full in glob.glob(os.path.join(self.dir,'*.idx')):
if not d.get(full):
return '%d %s' % (date, time.strftime('%z', time.localtime(date)))
-def _gitenv():
- os.environ['GIT_DIR'] = os.path.abspath(repo())
+def _gitenv(repo_dir = None):
+ if not repo_dir:
+ repo_dir = repo()
+ def env():
+ os.environ['GIT_DIR'] = os.path.abspath(repo_dir)
+ return env
-def list_refs(refname = None):
+def list_refs(refname = None, repo_dir = None):
"""Generate a list of tuples in the form (refname,hash).
If a ref name is specified, list only this particular ref.
"""
argv = ['git', 'show-ref', '--']
if refname:
argv += [refname]
- p = subprocess.Popen(argv, preexec_fn = _gitenv, stdout = subprocess.PIPE)
+ p = subprocess.Popen(argv,
+ preexec_fn = _gitenv(repo_dir),
+ stdout = subprocess.PIPE)
out = p.stdout.read().strip()
rv = p.wait() # not fatal
if rv:
yield (name, sha.decode('hex'))
-def read_ref(refname):
+def read_ref(refname, repo_dir = None):
"""Get the commit id of the most recent commit made on a given ref."""
- l = list(list_refs(refname))
+ l = list(list_refs(refname, repo_dir))
if l:
assert(len(l) == 1)
return l[0][1]
return None
-def rev_list(ref, count=None):
+def rev_list(ref, count=None, repo_dir=None):
"""Generate a list of reachable commits in reverse chronological order.
This generator walks through commits, from child to parent, that are
if count:
opts += ['-n', str(atoi(count))]
argv = ['git', 'rev-list', '--pretty=format:%at'] + opts + [ref, '--']
- p = subprocess.Popen(argv, preexec_fn = _gitenv, stdout = subprocess.PIPE)
+ p = subprocess.Popen(argv,
+ preexec_fn = _gitenv(repo_dir),
+ stdout = subprocess.PIPE)
commit = None
for row in p.stdout:
s = row.strip()
raise GitError, 'git rev-list returned error %d' % rv
-def get_commit_dates(refs):
- """Get the dates for the specified commit refs."""
+def get_commit_dates(refs, repo_dir=None):
+ """Get the dates for the specified commit refs. For now, every unique
+ string in refs must resolve to a different commit or this
+ function will fail."""
result = []
- cmd = ['git', 'show', '-s', '--pretty=format:%ct']
- for chunk in batchpipe(cmd, refs, preexec_fn=_gitenv):
- result += [int(x) for x in chunk.splitlines()]
+ for ref in refs:
+ commit = get_commit_items(ref, cp(repo_dir))
+ result.append(commit.author_sec)
return result
-def rev_parse(committish):
+def rev_parse(committish, repo_dir=None):
"""Resolve the full hash for 'committish', if it exists.
Should be roughly equivalent to 'git rev-parse'.
Returns the hex value of the hash if it is found, None if 'committish' does
not correspond to anything.
"""
- head = read_ref(committish)
+ head = read_ref(committish, repo_dir=repo_dir)
if head:
debug2("resolved from ref: commit = %s\n" % head.encode('hex'))
return head
- pL = PackIdxList(repo('objects/pack'))
+ pL = PackIdxList(repo('objects/pack', repo_dir=repo_dir))
if len(committish) == 40:
try:
return None
-def update_ref(refname, newval, oldval):
+def update_ref(refname, newval, oldval, repo_dir=None):
"""Change the commit pointed to by a branch."""
if not oldval:
oldval = ''
assert(refname.startswith('refs/heads/'))
p = subprocess.Popen(['git', 'update-ref', refname,
newval.encode('hex'), oldval.encode('hex')],
- preexec_fn = _gitenv)
+ preexec_fn = _gitenv(repo_dir))
_git_wait('git update-ref', p)
if os.path.exists(d) and not os.path.isdir(os.path.join(d, '.')):
raise GitError('"%s" exists but is not a directory\n' % d)
p = subprocess.Popen(['git', '--bare', 'init'], stdout=sys.stderr,
- preexec_fn = _gitenv)
+ preexec_fn = _gitenv())
_git_wait('git init', p)
# Force the index version configuration in order to ensure bup works
# regardless of the version of the installed Git binary.
p = subprocess.Popen(['git', 'config', 'pack.indexVersion', '2'],
- stdout=sys.stderr, preexec_fn = _gitenv)
+ stdout=sys.stderr, preexec_fn = _gitenv())
_git_wait('git config', p)
# Enable the reflog
p = subprocess.Popen(['git', 'config', 'core.logAllRefUpdates', 'true'],
- stdout=sys.stderr, preexec_fn = _gitenv)
+ stdout=sys.stderr, preexec_fn = _gitenv())
_git_wait('git config', p)
def _git_capture(argv):
- p = subprocess.Popen(argv, stdout=subprocess.PIPE, preexec_fn = _gitenv)
+ p = subprocess.Popen(argv, stdout=subprocess.PIPE, preexec_fn = _gitenv())
r = p.stdout.read()
_git_wait(repr(argv), p)
return r
_ver_warned = 0
class CatPipe:
"""Link to 'git cat-file' that is used to retrieve blob data."""
- def __init__(self):
+ def __init__(self, repo_dir = None):
global _ver_warned
+ self.repo_dir = repo_dir
wanted = ('1','5','6')
if ver() < wanted:
if not _ver_warned:
stdout=subprocess.PIPE,
close_fds = True,
bufsize = 4096,
- preexec_fn = _gitenv)
+ preexec_fn = _gitenv(self.repo_dir))
def _fast_get(self, id):
if not self.p or self.p.poll() != None:
p = subprocess.Popen(['git', 'cat-file', type, id],
stdout=subprocess.PIPE,
- preexec_fn = _gitenv)
+ preexec_fn = _gitenv(self.repo_dir))
for blob in chunkyreader(p.stdout):
yield blob
_git_wait('git cat-file', p)
except StopIteration:
log('booger!\n')
-def tags():
+
+_cp = {}
+
+def cp(repo_dir=None):
+ """Create a CatPipe object or reuse the already existing one."""
+ global _cp
+ if not repo_dir:
+ repo_dir = repo()
+ repo_dir = os.path.abspath(repo_dir)
+ cp = _cp.get(repo_dir)
+ if not cp:
+ cp = CatPipe(repo_dir)
+ _cp[repo_dir] = cp
+ return cp
+
+
+def tags(repo_dir = None):
"""Return a dictionary of all tags in the form {hash: [tag_names, ...]}."""
tags = {}
- for (n,c) in list_refs():
+ for (n,c) in list_refs(repo_dir = repo_dir):
if n.startswith('refs/tags/'):
name = n[10:]
if not c in tags:
tags[c] = []
tags[c].append(name) # more than one tag can point at 'c'
-
return tags
projects / bup.git / blobdiff