cmd-index.py

   1 #!/usr/bin/env python2.5
   2 import sys, re, errno, stat, tempfile, struct, mmap
   3 import options
   4 from helpers import *
   5
   6 INDEX_SIG = '!IIIIIQ20sH'
   7 ENTLEN = struct.calcsize(INDEX_SIG)
   8
   9 IX_EXISTS = 0x8000
  10 IX_HASHVALID = 0x4000
  11
  12
  13 class OsFile:
  14     def __init__(self, path):
  15         self.fd = None
  16         self.fd = os.open(path, os.O_RDONLY|os.O_LARGEFILE|os.O_NOFOLLOW)
  17         #self.st = os.fstat(self.fd)
  18
  19     def __del__(self):
  20         if self.fd:
  21             fd = self.fd
  22             self.fd = None
  23             os.close(fd)
  24
  25     def fchdir(self):
  26         os.fchdir(self.fd)
  27
  28
  29 class IxEntry:
  30     def __init__(self, name, m, ofs):
  31         self._m = m
  32         self._ofs = ofs
  33         self.name = str(name)
  34         (self.dev, self.ctime, self.mtime, self.uid, self.gid,
  35          self.size, self.sha,
  36          self.flags) = struct.unpack(INDEX_SIG, buffer(m, ofs, ENTLEN))
  37
  38     def __repr__(self):
  39         return ("(%s,0x%04x,%d,%d,%d,%d,%d,0x%04x)"
  40                 % (self.name, self.dev,
  41                    self.ctime, self.mtime, self.uid, self.gid,
  42                    self.size, self.flags))
  43
  44     def pack(self):
  45         return struct.pack(INDEX_SIG, self.dev, self.ctime, self.mtime,
  46                            self.uid, self.gid, self.size, self.sha,
  47                            self.flags)
  48
  49     def repack(self):
  50         self._m[self._ofs:self._ofs+ENTLEN] = self.pack()
  51
  52     def from_stat(self, st):
  53         old = (self.dev, self.ctime, self.mtime,
  54                self.uid, self.gid, self.size)
  55         new = (st.st_dev, int(st.st_ctime), int(st.st_mtime),
  56                st.st_uid, st.st_gid, st.st_size)
  57         self.dev = st.st_dev
  58         self.ctime = int(st.st_ctime)
  59         self.mtime = int(st.st_mtime)
  60         self.uid = st.st_uid
  61         self.gid = st.st_gid
  62         self.size = st.st_size
  63         self.flags |= IX_EXISTS
  64         if old != new:
  65             self.flags &= ~IX_HASHVALID
  66             return 1  # dirty
  67         else:
  68             return 0  # not dirty
  69
  70
  71 class IndexReader:
  72     def __init__(self, filename):
  73         self.filename = filename
  74         self.m = ''
  75         self.writable = False
  76         f = None
  77         try:
  78             f = open(filename, 'r+')
  79         except IOError, e:
  80             if e.errno == errno.ENOENT:
  81                 pass
  82             else:
  83                 raise
  84         if f:
  85             st = os.fstat(f.fileno())
  86         if f and st.st_size:
  87             self.m = mmap.mmap(f.fileno(), 0,
  88                                mmap.MAP_SHARED, mmap.PROT_READ|mmap.PROT_WRITE)
  89             f.close()  # map will persist beyond file close
  90             self.writable = True
  91
  92     def __iter__(self):
  93         ofs = 0
  94         while ofs < len(self.m):
  95             eon = self.m.find('\0', ofs)
  96             assert(eon >= 0)
  97             yield IxEntry(buffer(self.m, ofs, eon-ofs),
  98                           self.m, eon+1)
  99             ofs = eon + 1 + ENTLEN
 100
 101     def save(self):
 102         if self.writable:
 103             self.m.flush()
 104
 105
 106 def ix_encode(st, sha, flags):
 107     return struct.pack(INDEX_SIG, st.st_dev, int(st.st_ctime),
 108                        int(st.st_mtime), st.st_uid, st.st_gid,
 109                        st.st_size, sha, flags)
 110
 111
 112 class IndexWriter:
 113     def __init__(self, filename):
 114         self.f = None
 115         self.lastfile = None
 116         self.filename = None
 117         self.filename = filename = os.path.realpath(filename)
 118         (dir,name) = os.path.split(filename)
 119         (ffd,self.tmpname) = tempfile.mkstemp('.tmp', filename, dir)
 120         self.f = os.fdopen(ffd, 'wb', 65536)
 121
 122     def __del__(self):
 123         self.abort()
 124
 125     def abort(self):
 126         f = self.f
 127         self.f = None
 128         if f:
 129             f.close()
 130             os.unlink(self.tmpname)
 131
 132     def close(self):
 133         f = self.f
 134         self.f = None
 135         if f:
 136             f.close()
 137             os.rename(self.tmpname, self.filename)
 138
 139     def add(self, name, st):
 140         #log('ADDING %r\n' % name)
 141         if self.lastfile:
 142             assert(cmp(self.lastfile, name) > 0) # reverse order only
 143         self.lastfile = name
 144         data = name + '\0' + ix_encode(st, '\0'*20, IX_EXISTS|IX_HASHVALID)
 145         self.f.write(data)
 146
 147     def add_ixentry(self, e):
 148         if self.lastfile:
 149             assert(cmp(self.lastfile, e.name) > 0) # reverse order only
 150         self.lastfile = e.name
 151         data = e.name + '\0' + e.pack()
 152         self.f.write(data)
 153
 154     def new_reader(self):
 155         self.f.flush()
 156         return IndexReader(self.tmpname)
 157
 158
 159 saved_errors = []
 160 def add_error(e):
 161     saved_errors.append(e)
 162     log('\n%s\n' % e)
 163
 164
 165 # the use of fchdir() and lstat() are for two reasons:
 166 #  - help out the kernel by not making it repeatedly look up the absolute path
 167 #  - avoid race conditions caused by doing listdir() on a changing symlink
 168 def handle_path(ri, wi, dir, name, pst, xdev):
 169     dirty = 0
 170     path = dir + name
 171     #log('handle_path(%r,%r)\n' % (dir, name))
 172     if stat.S_ISDIR(pst.st_mode):
 173         if opt.verbose == 1: # log dirs only
 174             sys.stdout.write('%s\n' % path)
 175             sys.stdout.flush()
 176         try:
 177             OsFile(name).fchdir()
 178         except OSError, e:
 179             add_error(Exception('in %s: %s' % (dir, str(e))))
 180             return 0
 181         try:
 182             try:
 183                 ld = os.listdir('.')
 184                 #log('* %r: %r\n' % (name, ld))
 185             except OSError, e:
 186                 add_error(Exception('in %s: %s' % (path, str(e))))
 187                 return 0
 188             lds = []
 189             for p in ld:
 190                 try:
 191                     st = os.lstat(p)
 192                 except OSError, e:
 193                     add_error(Exception('in %s: %s' % (path, str(e))))
 194                     continue
 195                 if xdev != None and st.st_dev != xdev:
 196                     log('Skipping %r: different filesystem.\n'
 197                         % os.path.realpath(p))
 198                     continue
 199                 if stat.S_ISDIR(st.st_mode):
 200                     p += '/'
 201                 lds.append((p, st))
 202             for p,st in reversed(sorted(lds)):
 203                 dirty += handle_path(ri, wi, path, p, st, xdev)
 204         finally:
 205             os.chdir('..')
 206     #log('endloop: ri.cur:%r path:%r\n' % (ri.cur.name, path))
 207     while ri.cur and ri.cur.name > path:
 208         #log('ricur:%r path:%r\n' % (ri.cur, path))
 209         if dir and ri.cur.name.startswith(dir):
 210             #log('    --- deleting\n')
 211             ri.cur.flags &= ~(IX_EXISTS | IX_HASHVALID)
 212             ri.cur.repack()
 213             dirty += 1
 214         ri.next()
 215     if ri.cur and ri.cur.name == path:
 216         dirty += ri.cur.from_stat(pst)
 217         if dirty:
 218             #log('   --- updating %r\n' % path)
 219             ri.cur.repack()
 220         ri.next()
 221     else:
 222         wi.add(path, pst)
 223         dirty += 1
 224     if opt.verbose > 1:  # all files, not just dirs
 225         sys.stdout.write('%s\n' % path)
 226         sys.stdout.flush()
 227     return dirty
 228
 229
 230 def _next(i):
 231     try:
 232         return i.next()
 233     except StopIteration:
 234         return None
 235
 236
 237 def merge_indexes(out, r1, r2):
 238     log('Merging indexes.\n')
 239     i1 = iter(r1)
 240     i2 = iter(r2)
 241
 242     e1 = _next(i1)
 243     e2 = _next(i2)
 244     while e1 or e2:
 245         if e1 and (not e2 or e2.name < e1.name):
 246             if e1.flags & IX_EXISTS:
 247                 out.add_ixentry(e1)
 248             e1 = _next(i1)
 249         elif e2 and (not e1 or e1.name < e2.name):
 250             if e2.flags & IX_EXISTS:
 251                 out.add_ixentry(e2)
 252             e2 = _next(i2)
 253         elif e1.name == e2.name:
 254             assert(0)  # duplicate name? should never happen anymore.
 255             if e2.flags & IX_EXISTS:
 256                 out.add_ixentry(e2)
 257             e1 = _next(i1)
 258             e2 = _next(i2)
 259
 260
 261 class MergeGetter:
 262     def __init__(self, l):
 263         self.i = iter(l)
 264         self.cur = None
 265         self.next()
 266
 267     def next(self):
 268         try:
 269             self.cur = self.i.next()
 270         except StopIteration:
 271             self.cur = None
 272         return self.cur
 273
 274
 275 def update_index(path):
 276     ri = IndexReader('index')
 277     wi = IndexWriter('index')
 278     rpath = os.path.realpath(path)
 279     st = os.lstat(rpath)
 280     if opt.xdev:
 281         xdev = st.st_dev
 282     else:
 283         xdev = None
 284     f = OsFile('.')
 285     if rpath[-1] == '/':
 286         rpath = rpath[:-1]
 287     (dir, name) = os.path.split(rpath)
 288     if dir and dir[-1] != '/':
 289         dir += '/'
 290     if stat.S_ISDIR(st.st_mode) and (not rpath or rpath[-1] != '/'):
 291         name += '/'
 292     rig = MergeGetter(ri)
 293     OsFile(dir or '/').fchdir()
 294     dirty = handle_path(rig, wi, dir, name, st, xdev)
 295
 296     # make sure all the parents of the updated path exist and are invalidated
 297     # if appropriate.
 298     while 1:
 299         (rpath, junk) = os.path.split(rpath)
 300         if not rpath:
 301             break
 302         elif rpath == '/':
 303             p = rpath
 304         else:
 305             p = rpath + '/'
 306         while rig.cur and rig.cur.name > p:
 307             #log('FINISHING: %r path=%r d=%r\n' % (rig.cur.name, p, dirty))
 308             rig.next()
 309         if rig.cur and rig.cur.name == p:
 310             if dirty:
 311                 rig.cur.flags &= ~IX_HASHVALID
 312                 rig.cur.repack()
 313         else:
 314             wi.add(p, os.lstat(p))
 315         if p == '/':
 316             break
 317
 318     f.fchdir()
 319     ri.save()
 320     mi = IndexWriter('index')
 321     merge_indexes(mi, ri, wi.new_reader())
 322     wi.abort()
 323     mi.close()
 324
 325
 326 optspec = """
 327 bup index [-vp] <filenames...>
 328 --
 329 p,print    print index after updating
 330 x,xdev,one-file-system  don't cross filesystem boundaries
 331 v,verbose  increase log output (can be used more than once)
 332 """
 333 o = options.Options('bup index', optspec)
 334 (opt, flags, extra) = o.parse(sys.argv[1:])
 335
 336 for path in extra:
 337     update_index(path)
 338
 339 if opt['print']:
 340     for ent in IndexReader('index'):
 341         if not ent.flags & IX_EXISTS:
 342             print 'D ' + ent.name
 343         elif not ent.flags & IX_HASHVALID:
 344             print 'M ' + ent.name
 345         else:
 346             print '  ' + ent.name
 347         #print repr(ent)
 348
 349 if saved_errors:
 350     log('WARNING: %d errors encountered.\n' % len(saved_errors))
 351     exit(1)