import sys, stat, time, os
from bup import options, git, index, drecurse
from bup.helpers import *
-
+from bup.hashsplit import GIT_MODE_TREE, GIT_MODE_FILE
class IterHelper:
def __init__(self, l):
hashgen = None
if opt.fake_valid:
def hashgen(name):
- return (0100644, index.FAKE_SHA)
+ return (GIT_MODE_FILE, index.FAKE_SHA)
total = 0
bup_dir = os.path.abspath(git.repo())
import sys, stat, time, math
from bup import hashsplit, git, options, index, client
from bup.helpers import *
+from bup.hashsplit import GIT_MODE_TREE, GIT_MODE_FILE
optspec = """
shalist = shalists.pop()
tree = force_tree or w.new_tree(shalist)
if shalists:
- shalists[-1].append(('40000',
- git.mangle_name(part, 040000, 40000),
+ shalists[-1].append((GIT_MODE_TREE,
+ git.mangle_name(part,
+ GIT_MODE_TREE, GIT_MODE_TREE),
tree))
else: # this was the toplevel, so put it back for sanity
shalists.append(shalist)
if lastskip_name and lastskip_name.startswith(ent.name):
ent.invalidate()
else:
- ent.validate(040000, newtree)
+ ent.validate(GIT_MODE_TREE, newtree)
ent.repack()
if exists and wasmissing:
count += oldsize
# it's not a directory
id = None
if hashvalid:
- mode = '%o' % ent.gitmode
id = ent.sha
- shalists[-1].append((mode,
+ shalists[-1].append((ent.gitmode,
git.mangle_name(file, ent.mode, ent.gitmode),
id))
else:
add_error(Exception('skipping special file "%s"' % ent.name))
lastskip_name = ent.name
if id:
- ent.validate(int(mode, 8), id)
+ ent.validate(mode, id)
ent.repack()
shalists[-1].append((mode,
git.mangle_name(file, ent.mode, ent.gitmode),
def _shalist_sort_key(ent):
(mode, name, id) = ent
- if stat.S_ISDIR(int(mode, 8)):
+ assert(mode+0 == mode)
+ if stat.S_ISDIR(mode):
return name + '/'
else:
return name
l = []
for (mode,name,bin) in shalist:
assert(mode)
- assert(mode != '0')
- assert(mode[0] != '0')
+ assert(mode+0 == mode)
assert(name)
assert(len(bin) == 20)
- l.append('%s %s\0%s' % (mode,name,bin))
+ s = '%o %s\0%s' % (mode,name,bin)
+ assert(s[0] != '0') # 0-padded octal is not acceptable in a git tree
+ l.append(s)
return ''.join(l)
assert(z > 0)
spl = buf[ofs:ofs+z].split(' ', 1)
assert(len(spl) == 2)
+ mode,name = spl
sha = buf[ofs+z+1:ofs+z+1+20]
ofs += z+1+20
- yield (spl[0], spl[1], sha)
+ yield (int(mode, 8), name, sha)
def _encode_packobj(type, content):
progress_callback = None
fanout = 16
+GIT_MODE_FILE = 0100644
+GIT_MODE_TREE = 040000
+assert(GIT_MODE_TREE != 40000) # 0xxx should be treated as octal
+
# The purpose of this type of buffer is to avoid copying on peek(), get(),
# and eat(). We do copy the buffer contents on put(), but that should
# be ok if we always only put() large amounts of data at a time.
elif stacks[i]:
(shalist, size) = _make_shalist(stacks[i])
tree = maketree(shalist)
- stacks[i+1].append(('40000', tree, size))
+ stacks[i+1].append((GIT_MODE_TREE, tree, size))
stacks[i] = []
i += 1
if not fanout:
shal = []
for (sha,size,level) in sl:
- shal.append(('100644', sha, size))
+ shal.append((GIT_MODE_FILE, sha, size))
return _make_shalist(shal)[0]
else:
stacks = [[]]
for (sha,size,level) in sl:
- stacks[0].append(('100644', sha, size))
+ stacks[0].append((GIT_MODE_FILE, sha, size))
if level:
_squish(maketree, stacks, level)
#log('stacks: %r\n' % [len(i) for i in stacks])
if len(shalist) == 1:
return (shalist[0][0], shalist[0][2])
elif len(shalist) == 0:
- return ('100644', makeblob(''))
+ return (GIT_MODE_FILE, makeblob(''))
else:
- return ('40000', maketree(shalist))
+ return (GIT_MODE_TREE, maketree(shalist))
def open_noatime(name):
def validate(self, gitmode, sha):
assert(sha)
assert(gitmode)
+ assert(gitmode+0 == gitmode)
self.gitmode = gitmode
self.sha = sha
self.flags |= IX_HASHVALID|IX_EXISTS
import os, re, stat, time
from bup import git
from helpers import *
+from bup.hashsplit import GIT_MODE_TREE, GIT_MODE_FILE
EMPTY_SHA='\0'*20
def _tree_decode(hash):
- tree = [(int(name,16),stat.S_ISDIR(int(mode,8)),sha)
+ tree = [(int(name,16),stat.S_ISDIR(mode),sha)
for (mode,name,sha)
in _treeget(hash)]
assert(tree == list(sorted(tree)))
type = it.next()
assert(type == 'tree')
for (mode,mangled_name,sha) in git.tree_decode(''.join(it)):
- mode = int(mode, 8)
name = mangled_name
(name,bupmode) = git.demangle_name(mangled_name)
if bupmode == git.BUP_CHUNKED:
- mode = 0100644
+ mode = GIT_MODE_FILE
if stat.S_ISDIR(mode):
self._subs[name] = Dir(self, name, mode, sha)
elif stat.S_ISLNK(mode):
the number of commits grows big.
"""
def __init__(self, parent, name):
- Node.__init__(self, parent, name, 040000, EMPTY_SHA)
+ Node.__init__(self, parent, name, GIT_MODE_TREE, EMPTY_SHA)
def _mksubs(self):
self._subs = {}
class CommitList(Node):
"""A list of commits with hashes that start with the current node's name."""
def __init__(self, parent, name):
- Node.__init__(self, parent, name, 040000, EMPTY_SHA)
+ Node.__init__(self, parent, name, GIT_MODE_TREE, EMPTY_SHA)
self.commits = {}
def _mksubs(self):
self._subs = {}
for (name, (hash, date)) in self.commits.items():
- n1 = Dir(self, name, 040000, hash)
+ n1 = Dir(self, name, GIT_MODE_TREE, hash)
n1.ctime = n1.mtime = date
self._subs[name] = n1
class TagDir(Node):
"""A directory that contains all tags in the repository."""
def __init__(self, parent, name):
- Node.__init__(self, parent, name, 040000, EMPTY_SHA)
+ Node.__init__(self, parent, name, GIT_MODE_TREE, EMPTY_SHA)
def _mksubs(self):
self._subs = {}
/.commit/??/ . The symlink is named after the commit date.
"""
def __init__(self, parent, name, hash):
- Node.__init__(self, parent, name, 040000, hash)
+ Node.__init__(self, parent, name, GIT_MODE_TREE, hash)
def _mksubs(self):
self._subs = {}
that are reachable via a ref (e.g. a branch). See CommitDir for details.
"""
def __init__(self, parent):
- Node.__init__(self, parent, '/', 040000, EMPTY_SHA)
+ Node.__init__(self, parent, '/', GIT_MODE_TREE, EMPTY_SHA)
def _mksubs(self):
self._subs = {}
a
./"
WVPASS bup save -t $D/d
+WVPASS bup index --fake-invalid $D/d/z
+WVPASS bup save -t $D/d/z
+WVPASS bup save -t $D/d/z # test regenerating trees when no files are changed
+WVPASS bup save -t $D/d
WVPASSEQ "$(cd $D && bup index -m)" \
"f
a
projects / bup.git / commitdiff