def report_live_item(n, total, ref_name, ref_id, item, verbosity):
status = 'scanned %02.2f%%' % (n * 100.0 / total)
hex_id = ref_id.encode('hex')
dirslash = '/' if item.type == 'tree' else ''
chunk_path = item.chunk_path
if chunk_path:
if verbosity < 4:
return
ps = '/'.join(item.path)
chunk_ps = '/'.join(chunk_path)
log('%s %s:%s/%s%s\n' % (status, hex_id, ps, chunk_ps, dirslash))
return
# Top commit, for example has none.
demangled = git.demangle_name(item.path[-1], item.mode)[0] if item.path \
else None
# Don't print mangled paths unless the verbosity is over 3.
if demangled:
ps = '/'.join(item.path[:-1] + [demangled])
if verbosity == 1:
qprogress('%s %s:%s%s\r' % (status, hex_id, ps, dirslash))
elif (verbosity > 1 and item.type == 'tree') \
or (verbosity > 2 and item.type == 'blob'):
log('%s %s:%s%s\n' % (status, hex_id, ps, dirslash))
elif verbosity > 3:
ps = '/'.join(item.path)
log('%s %s:%s%s\n' % (status, hex_id, ps, dirslash))
def report_live_item(n, total, ref_name, ref_id, item, verbosity):
status = 'scanned %02.2f%%' % (n * 100.0 / total)
hex_id = hexstr(ref_id)
dirslash = b'/' if item.type == b'tree' else b''
chunk_path = item.chunk_path
if chunk_path:
if verbosity < 4:
return
ps = b'/'.join(item.path)
chunk_ps = b'/'.join(chunk_path)
log('%s %s:%s/%s%s\n' % (status, hex_id, path_msg(ps),
path_msg(chunk_ps), path_msg(dirslash)))
return
# Top commit, for example has none.
demangled = git.demangle_name(item.path[-1], item.mode)[0] if item.path \
else None
# Don't print mangled paths unless the verbosity is over 3.
if demangled:
ps = b'/'.join(item.path[:-1] + [demangled])
if verbosity == 1:
qprogress('%s %s:%s%s\r' %
(status, hex_id, path_msg(ps), path_msg(dirslash)))
elif (verbosity > 1 and item.type == b'tree') \
or (verbosity > 2 and item.type == b'blob'):
log('%s %s:%s%s\n' %
(status, hex_id, path_msg(ps), path_msg(dirslash)))
elif verbosity > 3:
ps = b'/'.join(item.path)
log('%s %s:%s%s\n' %
(status, hex_id, path_msg(ps), path_msg(dirslash)))
def _mksubs(self):
self._subs = {}
it = cp(self._repo_dir).get(self.hash.encode('hex'))
type = it.next()
if type == 'commit':
del it
it = cp(self._repo_dir).get(self.hash.encode('hex') + ':')
type = it.next()
assert (type == 'tree')
for (mode, mangled_name, sha) in git.tree_decode(''.join(it)):
if mangled_name == '.bupm':
bupmode = stat.S_ISDIR(mode) and BUP_CHUNKED or BUP_NORMAL
self._bupm = File(self, mangled_name, GIT_MODE_FILE, sha,
bupmode)
continue
(name, bupmode) = git.demangle_name(mangled_name)
if bupmode == git.BUP_CHUNKED:
mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha, self._repo_dir)
elif stat.S_ISLNK(mode):
self._subs[name] = Symlink(self, name, sha, bupmode,
self._repo_dir)
else:
self._subs[name] = File(self, name, mode, sha, bupmode,
self._repo_dir)
def report_live_item(n, total, ref_name, ref_id, item):
global opt
status = 'scanned %02.2f%%' % (n * 100.0 / total)
hex_id = ref_id.encode('hex')
dirslash = '/' if item.type == 'tree' else ''
chunk_path = item.chunk_path
if chunk_path:
if opt.verbose < 4:
return
ps = '/'.join(item.path)
chunk_ps = '/'.join(chunk_path)
log('%s %s:%s/%s%s\n' % (status, hex_id, ps, chunk_ps, dirslash))
return
# Top commit, for example has none.
demangled = git.demangle_name(item.path[-1], item.mode)[0] if item.path \
else None
# Don't print mangled paths unless the verbosity is over 3.
if demangled:
ps = '/'.join(item.path[:-1] + [demangled])
if opt.verbose == 1:
qprogress('%s %s:%s%s\r' % (status, hex_id, ps, dirslash))
elif (opt.verbose > 1 and item.type == 'tree') \
or (opt.verbose > 2 and item.type == 'blob'):
log('%s %s:%s%s\n' % (status, hex_id, ps, dirslash))
elif opt.verbose > 3:
ps = '/'.join(item.path)
log('%s %s:%s%s\n' % (status, hex_id, ps, dirslash))
def _mksubs(self):
self._subs = {}
it = cp(self._repo_dir).get(self.hash.encode('hex'))
type = it.next()
if type == 'commit':
del it
it = cp(self._repo_dir).get(self.hash.encode('hex') + ':')
type = it.next()
assert(type == 'tree')
for (mode,mangled_name,sha) in git.tree_decode(''.join(it)):
if mangled_name == '.bupm':
bupmode = stat.S_ISDIR(mode) and BUP_CHUNKED or BUP_NORMAL
self._bupm = File(self, mangled_name, GIT_MODE_FILE, sha,
bupmode)
continue
name, bupmode = git.demangle_name(mangled_name, mode)
if bupmode == git.BUP_CHUNKED:
mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha, self._repo_dir)
elif stat.S_ISLNK(mode):
self._subs[name] = Symlink(self, name, sha, bupmode,
self._repo_dir)
else:
self._subs[name] = File(self, name, mode, sha, bupmode,
self._repo_dir)
def testmangle():
afile = 0100644
afile2 = 0100770
alink = 0120000
adir = 0040000
adir2 = 0040777
WVPASSEQ(git.mangle_name("a", adir2, adir), "a")
WVPASSEQ(git.mangle_name(".bup", adir2, adir), ".bup.bupl")
WVPASSEQ(git.mangle_name("a.bupa", adir2, adir), "a.bupa.bupl")
WVPASSEQ(git.mangle_name("b.bup", alink, alink), "b.bup.bupl")
WVPASSEQ(git.mangle_name("b.bu", alink, alink), "b.bu")
WVPASSEQ(git.mangle_name("f", afile, afile2), "f")
WVPASSEQ(git.mangle_name("f.bup", afile, afile2), "f.bup.bupl")
WVPASSEQ(git.mangle_name("f.bup", afile, adir), "f.bup.bup")
WVPASSEQ(git.mangle_name("f", afile, adir), "f.bup")
WVPASSEQ(git.demangle_name("f.bup", afile), ("f", git.BUP_CHUNKED))
WVPASSEQ(git.demangle_name("f.bupl", afile), ("f", git.BUP_NORMAL))
WVPASSEQ(git.demangle_name("f.bup.bupl", afile), ("f.bup", git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(".bupm", afile), ('', git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(".bupm", adir), ('', git.BUP_CHUNKED))
# for safety, we ignore .bup? suffixes we don't recognize. Future
# versions might implement a .bup[a-z] extension as something other
# than BUP_NORMAL.
WVPASSEQ(git.demangle_name("f.bupa", afile), ("f.bupa", git.BUP_NORMAL))
def testmangle():
with no_lingering_errors():
afile = 0o100644
afile2 = 0o100770
alink = 0o120000
adir = 0o040000
adir2 = 0o040777
WVPASSEQ(git.mangle_name(b'a', adir2, adir), b'a')
WVPASSEQ(git.mangle_name(b'.bup', adir2, adir), b'.bup.bupl')
WVPASSEQ(git.mangle_name(b'a.bupa', adir2, adir), b'a.bupa.bupl')
WVPASSEQ(git.mangle_name(b'b.bup', alink, alink), b'b.bup.bupl')
WVPASSEQ(git.mangle_name(b'b.bu', alink, alink), b'b.bu')
WVPASSEQ(git.mangle_name(b'f', afile, afile2), b'f')
WVPASSEQ(git.mangle_name(b'f.bup', afile, afile2), b'f.bup.bupl')
WVPASSEQ(git.mangle_name(b'f.bup', afile, adir), b'f.bup.bup')
WVPASSEQ(git.mangle_name(b'f', afile, adir), b'f.bup')
WVPASSEQ(git.demangle_name(b'f.bup', afile), (b'f', git.BUP_CHUNKED))
WVPASSEQ(git.demangle_name(b'f.bupl', afile), (b'f', git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(b'f.bup.bupl', afile), (b'f.bup', git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(b'.bupm', afile), (b'', git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(b'.bupm', adir), (b'', git.BUP_CHUNKED))
# for safety, we ignore .bup? suffixes we don't recognize. Future
# versions might implement a .bup[a-z] extension as something other
# than BUP_NORMAL.
WVPASSEQ(git.demangle_name(b'f.bupa', afile), (b'f.bupa', git.BUP_NORMAL))
def testmangle():
afile = 0100644
afile2 = 0100770
alink = 0120000
adir = 0040000
adir2 = 0040777
WVPASSEQ(git.mangle_name("a", adir2, adir), "a")
WVPASSEQ(git.mangle_name(".bup", adir2, adir), ".bup.bupl")
WVPASSEQ(git.mangle_name("a.bupa", adir2, adir), "a.bupa.bupl")
WVPASSEQ(git.mangle_name("b.bup", alink, alink), "b.bup.bupl")
WVPASSEQ(git.mangle_name("b.bu", alink, alink), "b.bu")
WVPASSEQ(git.mangle_name("f", afile, afile2), "f")
WVPASSEQ(git.mangle_name("f.bup", afile, afile2), "f.bup.bupl")
WVPASSEQ(git.mangle_name("f.bup", afile, adir), "f.bup.bup")
WVPASSEQ(git.mangle_name("f", afile, adir), "f.bup")
WVPASSEQ(git.demangle_name("f.bup", afile), ("f", git.BUP_CHUNKED))
WVPASSEQ(git.demangle_name("f.bupl", afile), ("f", git.BUP_NORMAL))
WVPASSEQ(git.demangle_name("f.bup.bupl", afile), ("f.bup", git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(".bupm", afile), ('', git.BUP_NORMAL))
WVPASSEQ(git.demangle_name(".bupm", adir), ('', git.BUP_CHUNKED))
# for safety, we ignore .bup? suffixes we don't recognize. Future
# versions might implement a .bup[a-z] extension as something other
# than BUP_NORMAL.
WVPASSEQ(git.demangle_name("f.bupa", afile), ("f.bupa", git.BUP_NORMAL))
def walk_object(cat_pipe, id, verbose=None, parent_path=[], writer=None):
# Yield everything reachable from id via cat_pipe, stopping
# whenever we hit something writer already has. Produce (id, type
# data) for each item. Since maybe_write() can't accept an
# iterator, join()ing the data here doesn't hurt anything.
item_it = cat_pipe.get(id)
type = item_it.next()
data = ''.join(item_it)
id = git.calc_hash(type, data)
if writer and writer.exists(id):
return
if type == 'blob':
yield (id, type, data)
elif type == 'commit':
yield (id, type, data)
commit_items = parse_commit(data)
tree_id = commit_items.tree
for x in walk_object(cat_pipe, tree_id, verbose, parent_path, writer):
yield x
parents = commit_items.parents
for pid in parents:
for x in walk_object(cat_pipe, pid, verbose, parent_path, writer):
yield x
elif type == 'tree':
yield (id, type, data)
for (mode, name, ent_id) in git.tree_decode(data):
if not verbose > 1:
for x in walk_object(cat_pipe, ent_id.encode('hex'),
writer=writer):
yield x
else:
demangled, bup_type = git.demangle_name(name)
sub_path = parent_path + [demangled]
# Don't print the sub-parts of chunked files.
sub_v = verbose if bup_type == git.BUP_NORMAL else None
for x in walk_object(cat_pipe, ent_id.encode('hex'),
sub_v, sub_path, writer):
yield x
if stat.S_ISDIR(mode):
if verbose > 1 and bup_type == git.BUP_NORMAL:
log('%s/\n' % '/'.join(sub_path))
elif verbose > 2: # (and BUP_CHUNKED)
log('%s\n' % '/'.join(sub_path))
elif verbose > 2:
log('%s\n' % '/'.join(sub_path))
else:
raise Exception('unexpected repository object type %r' % type)
def _mksubs(self):
self._subs = {}
it = cp().get(self.hash.encode('hex'))
type = it.next()
if type == 'commit':
del it
it = cp().get(self.hash.encode('hex') + ':')
type = it.next()
assert (type == 'tree')
for (mode, mangled_name, sha) in git.tree_decode(''.join(it)):
name = mangled_name
(name, bupmode) = git.demangle_name(mangled_name)
if bupmode == git.BUP_CHUNKED:
mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha)
elif stat.S_ISLNK(mode):
self._subs[name] = Symlink(self, name, sha, bupmode)
else:
self._subs[name] = File(self, name, mode, sha, bupmode)
def _mksubs(self):
self._subs = {}
it = cp().get(self.hash.encode('hex'))
type = it.next()
if type == 'commit':
del it
it = cp().get(self.hash.encode('hex') + ':')
type = it.next()
assert(type == 'tree')
for (mode,mangled_name,sha) in git.tree_decode(''.join(it)):
name = mangled_name
(name,bupmode) = git.demangle_name(mangled_name)
if bupmode == git.BUP_CHUNKED:
mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha)
elif stat.S_ISLNK(mode):
self._subs[name] = Symlink(self, name, sha, bupmode)
else:
self._subs[name] = File(self, name, mode, sha, bupmode)
def _mksubs(self):
self._subs = {}
it = cp(self._repo_dir).get(self.hash.encode("hex"))
type = it.next()
if type == "commit":
del it
it = cp(self._repo_dir).get(self.hash.encode("hex") + ":")
type = it.next()
assert type == "tree"
for (mode, mangled_name, sha) in git.tree_decode("".join(it)):
if mangled_name == ".bupm":
bupmode = stat.S_ISDIR(mode) and BUP_CHUNKED or BUP_NORMAL
self._bupm = File(self, mangled_name, GIT_MODE_FILE, sha, bupmode)
continue
(name, bupmode) = git.demangle_name(mangled_name)
if bupmode == git.BUP_CHUNKED:
mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha, self._repo_dir)
elif stat.S_ISLNK(mode):
self._subs[name] = Symlink(self, name, sha, bupmode, self._repo_dir)
else:
self._subs[name] = File(self, name, mode, sha, bupmode, self._repo_dir)
def result_from_tree_entry(tree_entry):
gitmode, mangled_name, oid = tree_entry
name, kind = git.demangle_name(mangled_name, gitmode)
return name, mangled_name, kind, gitmode, oid
def result_from_tree_entry(tree_entry):
gitmode, mangled_name, oid = tree_entry
name, kind = git.demangle_name(mangled_name, gitmode)
return name, mangled_name, kind, gitmode, oid
