from bup.compat import range
from bup.helpers import (Sha1, add_error, chunkyreader, debug1, debug2,
fdatasync,
- hostname, localtime, log, merge_iter,
+ hostname, localtime, log,
+ merge_dict,
+ merge_iter,
mmap_read, mmap_readwrite,
parse_num,
progress, qprogress, shstr, stat_if_exists,
pass
+def _gitenv(repo_dir=None):
+ if not repo_dir:
+ repo_dir = repo()
+ return merge_dict(os.environ, {'GIT_DIR': os.path.abspath(repo_dir)})
+
def _git_wait(cmd, p):
rv = p.wait()
if rv != 0:
raise GitError('%s returned %d' % (shstr(cmd), rv))
def _git_capture(argv):
- p = subprocess.Popen(argv, stdout=subprocess.PIPE, preexec_fn = _gitenv())
+ p = subprocess.Popen(argv, stdout=subprocess.PIPE, env=_gitenv())
r = p.stdout.read()
_git_wait(repr(argv), p)
return r
def git_config_get(option, repo_dir=None):
cmd = ('git', 'config', '--get', option)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
- preexec_fn=_gitenv(repo_dir=repo_dir))
+ env=_gitenv(repo_dir=repo_dir))
r = p.stdout.read()
rc = p.wait()
if rc == 0:
_start_end_char, _content_char, _start_end_char)
_tz_rx = r'[-+]\d\d[0-5]\d'
_parent_rx = r'(?:parent [abcdefABCDEF0123456789]{40}\n)'
+# Assumes every following line starting with a space is part of the
+# mergetag. Is there a formal commit blob spec?
+_mergetag_rx = r'(?:\nmergetag object [abcdefABCDEF0123456789]{40}(?:\n [^\0\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)
+committer (?P<committer_name>%s) <(?P<committer_mail>%s)> (?P<csec>\d+) (?P<ctz>%s)(?P<mergetag>%s?)
(?P<message>(?:.|\n)*)''' % (_parent_rx,
_safe_str_rx, _safe_str_rx, _tz_rx,
- _safe_str_rx, _safe_str_rx, _tz_rx))
+ _safe_str_rx, _safe_str_rx, _tz_rx,
+ _mergetag_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.
+# Note that the author_sec and committer_sec values are (UTC) epoch
+# seconds, and for now the mergetag is not included.
CommitInfo = namedtuple('CommitInfo', ['tree', 'parents',
'author_name', 'author_mail',
'author_sec', 'author_offset',
message=matches['message'])
-def get_commit_items(id, cp):
- commit_it = cp.get(id)
- _, typ, _ = next(commit_it)
- assert(typ == 'commit')
- commit_content = ''.join(commit_it)
- return parse_commit(commit_content)
+def get_cat_data(cat_iterator, expected_type):
+ _, kind, _ = next(cat_iterator)
+ if kind != expected_type:
+ raise Exception('expected %r, saw %r' % (expected_type, kind))
+ return ''.join(cat_iterator)
+def get_commit_items(id, cp):
+ return parse_commit(get_cat_data(cp.get(id), 'commit'))
def _local_git_date_str(epoch_sec):
return '%d %s' % (epoch_sec, utc_offset_str(epoch_sec))
self.name = filename
self.idxnames = [self.name]
self.map = mmap_read(f)
- self.fanout = list(struct.unpack('!256I',
- str(buffer(self.map, 0, 256*4))))
+ self.fanout = list(struct.unpack('!256I', buffer(self.map, 0, 256 * 4)))
self.fanout.append(0) # entry "-1"
nsha = self.fanout[255]
self.sha_ofs = 256*4
self.shatable = buffer(self.map, self.sha_ofs, nsha*24)
def _ofs_from_idx(self, idx):
- return struct.unpack('!I', str(self.shatable[idx*24 : idx*24+4]))[0]
+ ofs = idx * 24
+ return struct.unpack('!I', self.shatable[ofs : ofs + 4])[0]
def _idx_to_hash(self, idx):
- return str(self.shatable[idx*24+4 : idx*24+24])
+ ofs = idx * 24 + 4
+ return self.shatable[ofs : ofs + 20]
def __iter__(self):
- for i in range(self.fanout[255]):
- yield buffer(self.map, 256*4 + 24*i + 4, 20)
+ count = self.fanout[255]
+ start = 256 * 4 + 4
+ for ofs in range(start, start + (24 * count), 24):
+ yield self.map[ofs : ofs + 20]
class PackIdxV2(PackIdx):
self.name = filename
self.idxnames = [self.name]
self.map = mmap_read(f)
- assert(str(self.map[0:8]) == '\377tOc\0\0\0\2')
+ assert self.map[0:8] == b'\377tOc\0\0\0\2'
self.fanout = list(struct.unpack('!256I',
- str(buffer(self.map, 8, 256*4))))
+ buffer(self.map[8 : 8 + 256 * 4])))
self.fanout.append(0) # entry "-1"
nsha = self.fanout[255]
self.sha_ofs = 8 + 256*4
8 + 256*4 + nsha*20 + nsha*4 + nsha*4)
def _ofs_from_idx(self, idx):
- ofs = struct.unpack('!I', str(buffer(self.ofstable, idx*4, 4)))[0]
+ i = idx * 4
+ ofs = struct.unpack('!I', self.ofstable[i : i + 4])[0]
if ofs & 0x80000000:
idx64 = ofs & 0x7fffffff
- ofs = struct.unpack('!Q',
- str(buffer(self.ofs64table, idx64*8, 8)))[0]
+ idx64_i = idx64 * 8
+ ofs = struct.unpack('!Q', self.ofs64table[idx64_i : idx64_i + 8])[0]
return ofs
def _idx_to_hash(self, idx):
- return str(self.shatable[idx*20:(idx+1)*20])
+ return self.shatable[idx * 20 : (idx + 1) * 20]
def __iter__(self):
- for i in range(self.fanout[255]):
- yield buffer(self.map, 8 + 256*4 + 20*i, 20)
+ count = self.fanout[255]
+ start = 8 + 256 * 4
+ for ofs in range(start, start + (20 * count), 20):
+ yield self.map[ofs : ofs + 20]
_mpi_count = 0
return self.objcache.exists(id, want_source=want_source)
def just_write(self, sha, type, content):
- """Write an object to the pack file, bypassing the objcache. Fails if
- sha exists()."""
+ """Write an object to the pack file without checking for duplication."""
self._write(sha, type, content)
+ # If nothing else, gc doesn't have/want an objcache
+ if self.objcache is not None:
+ self.objcache.add(sha)
def maybe_write(self, type, content):
"""Write an object to the pack file if not present and return its id."""
sha = calc_hash(type, content)
if not self.exists(sha):
- self.just_write(sha, type, content)
self._require_objcache()
- self.objcache.add(sha)
+ self.just_write(sha, type, content)
return sha
def new_blob(self, blob):
idx_f.close()
-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(patterns=None, repo_dir=None,
limit_to_heads=False, limit_to_tags=False):
"""Yield (refname, hash) tuples for all repository refs unless
argv.append('--')
if patterns:
argv.extend(patterns)
- p = subprocess.Popen(argv,
- preexec_fn = _gitenv(repo_dir),
- stdout = subprocess.PIPE)
+ p = subprocess.Popen(argv, env=_gitenv(repo_dir), stdout=subprocess.PIPE)
out = p.stdout.read().strip()
rv = p.wait() # not fatal
if rv:
assert bool(parse) == bool(format)
p = subprocess.Popen(rev_list_invocation(ref_or_refs, count=count,
format=format),
- preexec_fn = _gitenv(repo_dir),
+ env=_gitenv(repo_dir),
stdout = subprocess.PIPE)
if not format:
for line in p.stdout:
s = line.strip()
if not s.startswith('commit '):
raise Exception('unexpected line ' + s)
- yield s[7:], parse(p.stdout)
+ s = s[7:]
+ assert len(s) == 40
+ yield s, parse(p.stdout)
line = p.stdout.readline()
rv = p.wait() # not fatal
or refname.startswith('refs/tags/'))
p = subprocess.Popen(['git', 'update-ref', refname,
newval.encode('hex'), oldval.encode('hex')],
- preexec_fn = _gitenv(repo_dir))
+ env=_gitenv(repo_dir))
_git_wait('git update-ref', p)
assert(refname.startswith('refs/'))
oldvalue = [] if not oldvalue else [oldvalue]
p = subprocess.Popen(['git', 'update-ref', '-d', refname] + oldvalue,
- preexec_fn = _gitenv())
+ env=_gitenv())
_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())
+ env=_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, env=_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, env=_gitenv())
_git_wait('git config', p)
stdout=subprocess.PIPE,
close_fds = True,
bufsize = 4096,
- preexec_fn = _gitenv(self.repo_dir))
+ env=_gitenv(self.repo_dir))
def get(self, ref):
"""Yield (oidx, type, size), followed by the data referred to by ref.
# ...
-def walk_object(cat_pipe, oidx,
- stop_at=None,
- include_data=None):
- """Yield everything reachable from oidx via cat_pipe as a WalkItem,
- stopping whenever stop_at(oidx) returns true. Throw MissingObject
- if a hash encountered is missing from the repository, and don't
- read or return blob content in the data field unless include_data
- is set.
+def walk_object(get_ref, oidx, stop_at=None, include_data=None):
+ """Yield everything reachable from oidx via get_ref (which must behave
+ like CatPipe get) as a WalkItem, stopping whenever stop_at(oidx)
+ returns true. Throw MissingObject if a hash encountered is
+ missing from the repository, and don't read or return blob content
+ in the data field unless include_data is set.
+
"""
# Maintain the pending stack on the heap to avoid stack overflow
pending = [(oidx, [], [], None)]
data=None)
continue
- item_it = cat_pipe.get(oidx)
+ item_it = get_ref(oidx)
get_oidx, typ, _ = next(item_it)
if not get_oidx:
raise MissingObject(oidx.decode('hex'))
projects / bup.git / blobdiff