lib/bup/hlinkdb.py

   1
   2 import errno, os, pickle, tempfile
   3
   4 from bup.compat import pending_raise
   5
   6
   7 def pickle_load(f):
   8     return pickle.load(f, encoding='bytes')
   9
  10
  11 class Error(Exception):
  12     pass
  13
  14 class HLinkDB:
  15     def __init__(self, filename):
  16         self.closed = False
  17         # Map a "dev:ino" node to a list of paths associated with that node.
  18         self._node_paths = {}
  19         # Map a path to a "dev:ino" node.
  20         self._path_node = {}
  21         self._filename = filename
  22         self._save_prepared = None
  23         self._tmpname = None
  24         f = None
  25         try:
  26             f = open(filename, 'rb')
  27         except IOError as e:
  28             if e.errno == errno.ENOENT:
  29                 pass
  30             else:
  31                 raise
  32         if f:
  33             try:
  34                 self._node_paths = pickle_load(f)
  35             finally:
  36                 f.close()
  37                 f = None
  38         # Set up the reverse hard link index.
  39         for node, paths in self._node_paths.items():
  40             for path in paths:
  41                 self._path_node[path] = node
  42
  43     def prepare_save(self):
  44         """ Commit all of the relevant data to disk.  Do as much work
  45         as possible without actually making the changes visible."""
  46         if self._save_prepared:
  47             raise Error('save of %r already in progress' % self._filename)
  48         if self._node_paths:
  49             (dir, name) = os.path.split(self._filename)
  50             (ffd, self._tmpname) = tempfile.mkstemp(b'.tmp', name, dir)
  51             try:
  52                 try:
  53                     f = os.fdopen(ffd, 'wb', 65536)
  54                 except:
  55                     os.close(ffd)
  56                     raise
  57                 try:
  58                     pickle.dump(self._node_paths, f, 2)
  59                 finally:
  60                     f.close()
  61                     f = None
  62             except:
  63                 tmpname = self._tmpname
  64                 self._tmpname = None
  65                 os.unlink(tmpname)
  66                 raise
  67         self._save_prepared = True
  68
  69     def commit_save(self):
  70         self.closed = True
  71         if not self._save_prepared:
  72             raise Error('cannot commit save of %r; no save prepared'
  73                         % self._filename)
  74         if self._tmpname:
  75             os.rename(self._tmpname, self._filename)
  76             self._tmpname = None
  77         else: # No data -- delete _filename if it exists.
  78             try:
  79                 os.unlink(self._filename)
  80             except OSError as e:
  81                 if e.errno == errno.ENOENT:
  82                     pass
  83                 else:
  84                     raise
  85         self._save_prepared = None
  86
  87     def abort_save(self):
  88         self.closed = True
  89         if self._tmpname:
  90             os.unlink(self._tmpname)
  91             self._tmpname = None
  92
  93     def __enter__(self):
  94         return self
  95
  96     def __exit__(self, type, value, traceback):
  97         with pending_raise(value, rethrow=True):
  98             self.abort_save()
  99
 100     def __del__(self):
 101         assert self.closed
 102
 103     def add_path(self, path, dev, ino):
 104         # Assume path is new.
 105         node = b'%d:%d' % (dev, ino)
 106         self._path_node[path] = node
 107         link_paths = self._node_paths.get(node)
 108         if link_paths and path not in link_paths:
 109             link_paths.append(path)
 110         else:
 111             self._node_paths[node] = [path]
 112
 113     def _del_node_path(self, node, path):
 114         link_paths = self._node_paths[node]
 115         link_paths.remove(path)
 116         if not link_paths:
 117             del self._node_paths[node]
 118
 119     def change_path(self, path, new_dev, new_ino):
 120         prev_node = self._path_node.get(path)
 121         if prev_node:
 122             self._del_node_path(prev_node, path)
 123         self.add_path(new_dev, new_ino, path)
 124
 125     def del_path(self, path):
 126         # Path may not be in db (if updating a pre-hardlink support index).
 127         node = self._path_node.get(path)
 128         if node:
 129             self._del_node_path(node, path)
 130             del self._path_node[path]
 131
 132     def node_paths(self, dev, ino):
 133         node = b'%d:%d' % (dev, ino)
 134         return self._node_paths[node]