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 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