-import metadata, os, stat, struct, tempfile
+import errno, metadata, os, stat, struct, tempfile
+
from bup import xstat
-from bup.helpers import *
+from bup.helpers import (add_error, log, merge_iter, mmap_readwrite,
+ progress, qprogress, resolve_parent, slashappend)
+
EMPTY_SHA = '\0'*20
FAKE_SHA = '\x01'*20
-INDEX_HDR = 'BUPI\0\0\0\5'
+INDEX_HDR = 'BUPI\0\0\0\6'
# Time values are handled as integer nanoseconds since the epoch in
# memory, but are written as xstat/metadata timespecs. This behavior
# Record times (mtime, ctime, atime) as xstat/metadata timespecs, and
# store all of the times in the index so they won't interfere with the
# forthcoming metadata cache.
-INDEX_SIG = '!QQQqQqQqQIIQII20sHIIQ'
+INDEX_SIG = '!QQQqQqQqQQII20sHIIQ'
ENTLEN = struct.calcsize(INDEX_SIG)
FOOTER_SIG = '!Q'
class MetaStoreReader:
def __init__(self, filename):
+ self._file = None
self._file = open(filename, 'rb')
def close(self):
self.children_n = 0
def __repr__(self):
- return ("(%s,0x%04x,%d,%d,%d,%d,%d,%d,%d,%d,%s/%s,0x%04x,%d,0x%08x/%d)"
+ return ("(%s,0x%04x,%d,%d,%d,%d,%d,%d,%s/%s,0x%04x,%d,0x%08x/%d)"
% (self.name, self.dev, self.ino, self.nlink,
- self.ctime, self.mtime, self.atime, self.uid, self.gid,
+ self.ctime, self.mtime, self.atime,
self.size, self.mode, self.gitmode,
self.flags, self.meta_ofs,
self.children_ofs, self.children_n))
ctime[0], ctime[1],
mtime[0], mtime[1],
atime[0], atime[1],
- self.uid, self.gid, self.size, self.mode,
+ self.size, self.mode,
self.gitmode, self.sha, self.flags,
self.children_ofs, self.children_n,
self.meta_ofs)
- except (DeprecationWarning, struct.error), e:
+ except (DeprecationWarning, struct.error) as e:
log('pack error: %s (%r)\n' % (e, self))
raise
def from_stat(self, st, meta_ofs, tstart, check_device=True):
old = (self.dev if check_device else 0,
self.ino, self.nlink, self.ctime, self.mtime,
- self.uid, self.gid, self.size, self.flags & IX_EXISTS)
+ self.size, self.flags & IX_EXISTS)
new = (st.st_dev if check_device else 0,
st.st_ino, st.st_nlink, st.st_ctime, st.st_mtime,
- st.st_uid, st.st_gid, st.st_size, IX_EXISTS)
+ st.st_size, IX_EXISTS)
self.dev = st.st_dev
self.ino = st.st_ino
self.nlink = st.st_nlink
self.ctime = st.st_ctime
self.mtime = st.st_mtime
self.atime = st.st_atime
- self.uid = st.st_uid
- self.gid = st.st_gid
self.size = st.st_size
self.mode = st.st_mode
self.flags |= IX_EXISTS
self._fixup()
def _fixup(self):
- if self.uid < 0:
- self.uid += 0x100000000
- if self.gid < 0:
- self.gid += 0x100000000
- assert(self.uid >= 0)
- assert(self.gid >= 0)
self.mtime = self._fixup_time(self.mtime)
self.ctime = self._fixup_time(self.ctime)
class NewEntry(Entry):
def __init__(self, basename, name, tmax, dev, ino, nlink,
ctime, mtime, atime,
- uid, gid, size, mode, gitmode, sha, flags, meta_ofs,
+ size, mode, gitmode, sha, flags, meta_ofs,
children_ofs, children_n):
Entry.__init__(self, basename, name, meta_ofs, tmax)
(self.dev, self.ino, self.nlink, self.ctime, self.mtime, self.atime,
- self.uid, self.gid, self.size, self.mode, self.gitmode, self.sha,
+ self.size, self.mode, self.gitmode, self.sha,
self.flags, self.children_ofs, self.children_n
- ) = (dev, ino, nlink, ctime, mtime, atime, uid, gid,
+ ) = (dev, ino, nlink, ctime, mtime, atime,
size, mode, gitmode, sha, flags, children_ofs, children_n)
self._fixup()
class BlankNewEntry(NewEntry):
def __init__(self, basename, meta_ofs, tmax):
NewEntry.__init__(self, basename, basename, tmax,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
0, EMPTY_SHA, 0, meta_ofs, 0, 0)
self._ofs = ofs
(self.dev, self.ino, self.nlink,
self.ctime, ctime_ns, self.mtime, mtime_ns, self.atime, atime_ns,
- self.uid, self.gid, self.size, self.mode, self.gitmode, self.sha,
+ self.size, self.mode, self.gitmode, self.sha,
self.flags, self.children_ofs, self.children_n, self.meta_ofs
) = struct.unpack(INDEX_SIG, str(buffer(m, ofs, ENTLEN)))
self.atime = xstat.timespec_to_nsecs((self.atime, atime_ns))
f = None
try:
f = open(filename, 'r+')
- except IOError, e:
+ except IOError as e:
if e.errno == errno.ENOENT:
pass
else:
def __iter__(self):
return self.iter()
+ def find(self, name):
+ return next((e for e in self.iter(name, wantrecurse=lambda x : True)
+ if e.name == name),
+ None)
+
def exists(self):
return self.m
def filter(self, prefixes, wantrecurse=None):
for (rp, path) in reduce_paths(prefixes):
+ any_entries = False
for e in self.iter(rp, wantrecurse=wantrecurse):
+ any_entries = True
assert(e.name.startswith(rp))
name = path + e.name[len(rp):]
yield (name, e)
-
+ if not any_entries:
+ # Always return at least the top for each prefix.
+ # Otherwise something like "save x/y" will produce
+ # nothing if x is up to date.
+ pe = self.find(rp)
+ assert(pe)
+ name = path + pe.name[len(rp):]
+ yield (name, pe)
# FIXME: this function isn't very generic, because it splits the filename
# in an odd way and depends on a terminating '/' to indicate directories.
self.count = 0
self.lastfile = None
self.filename = None
- self.filename = filename = realpath(filename)
+ self.filename = filename = resolve_parent(filename)
self.metastore = metastore
self.tmax = tmax
(dir,name) = os.path.split(filename)
e = NewEntry(basename, name, self.tmax,
st.st_dev, st.st_ino, st.st_nlink,
st.st_ctime, st.st_mtime, st.st_atime,
- st.st_uid, st.st_gid,
st.st_size, st.st_mode, gitmode, sha, flags,
meta_ofs, 0, 0)
else:
def reduce_paths(paths):
xpaths = []
for p in paths:
- rp = realpath(p)
+ rp = resolve_parent(p)
try:
st = os.lstat(rp)
if stat.S_ISDIR(st.st_mode):
rp = slashappend(rp)
p = slashappend(p)
xpaths.append((rp, p))
- except OSError, e:
+ except OSError as e:
add_error('reduce_paths: %s' % e)
xpaths.sort()
projects / bup.git / blobdiff