src/allmydata/nodemaker.py

   1 import weakref
   2 from zope.interface import implements
   3 from allmydata.util.assertutil import precondition
   4 from allmydata.interfaces import INodeMaker
   5 from allmydata.immutable.literal import LiteralFileNode
   6 from allmydata.immutable.filenode import ImmutableFileNode, CiphertextFileNode
   7 from allmydata.immutable.upload import Data
   8 from allmydata.mutable.filenode import MutableFileNode
   9 from allmydata.mutable.publish import MutableData
  10 from allmydata.dirnode import DirectoryNode, pack_children
  11 from allmydata.unknown import UnknownNode
  12 from allmydata.blacklist import ProhibitedNode
  13 from allmydata import uri
  14
  15
  16 class NodeMaker:
  17     implements(INodeMaker)
  18
  19     def __init__(self, storage_broker, secret_holder, history,
  20                  uploader, terminator,
  21                  default_encoding_parameters, mutable_file_default,
  22                  key_generator, blacklist=None):
  23         self.storage_broker = storage_broker
  24         self.secret_holder = secret_holder
  25         self.history = history
  26         self.uploader = uploader
  27         self.terminator = terminator
  28         self.default_encoding_parameters = default_encoding_parameters
  29         self.mutable_file_default = mutable_file_default
  30         self.key_generator = key_generator
  31         self.blacklist = blacklist
  32
  33         self._node_cache = weakref.WeakValueDictionary() # uri -> node
  34
  35     def _create_lit(self, cap):
  36         return LiteralFileNode(cap)
  37     def _create_immutable(self, cap):
  38         return ImmutableFileNode(cap, self.storage_broker, self.secret_holder,
  39                                  self.terminator, self.history)
  40     def _create_immutable_verifier(self, cap):
  41         return CiphertextFileNode(cap, self.storage_broker, self.secret_holder,
  42                                   self.terminator, self.history)
  43     def _create_mutable(self, cap):
  44         n = MutableFileNode(self.storage_broker, self.secret_holder,
  45                             self.default_encoding_parameters,
  46                             self.history)
  47         return n.init_from_cap(cap)
  48     def _create_dirnode(self, filenode):
  49         return DirectoryNode(filenode, self, self.uploader)
  50
  51     def create_from_cap(self, writecap, readcap=None, deep_immutable=False, name=u"<unknown name>"):
  52         # this returns synchronously. It starts with a "cap string".
  53         assert isinstance(writecap, (str, type(None))), type(writecap)
  54         assert isinstance(readcap,  (str, type(None))), type(readcap)
  55
  56         bigcap = writecap or readcap
  57         if not bigcap:
  58             # maybe the writecap was hidden because we're in a readonly
  59             # directory, and the future cap format doesn't have a readcap, or
  60             # something.
  61             return UnknownNode(None, None)  # deep_immutable and name not needed
  62
  63         # The name doesn't matter for caching since it's only used in the error
  64         # attribute of an UnknownNode, and we don't cache those.
  65         if deep_immutable:
  66             memokey = "I" + bigcap
  67         else:
  68             memokey = "M" + bigcap
  69         if memokey in self._node_cache:
  70             node = self._node_cache[memokey]
  71         else:
  72             cap = uri.from_string(bigcap, deep_immutable=deep_immutable,
  73                                   name=name)
  74             node = self._create_from_single_cap(cap)
  75             if node:
  76                 self._node_cache[memokey] = node  # note: WeakValueDictionary
  77             else:
  78                 # don't cache UnknownNode
  79                 node = UnknownNode(writecap, readcap,
  80                                    deep_immutable=deep_immutable, name=name)
  81
  82         if self.blacklist:
  83             si = node.get_storage_index()
  84             # if this node is blacklisted, return the reason, otherwise return None
  85             reason = self.blacklist.check_storageindex(si)
  86             if reason is not None:
  87                 # The original node object is cached above, not the ProhibitedNode wrapper.
  88                 # This ensures that removing the blacklist entry will make the node
  89                 # accessible if create_from_cap is called again.
  90                 node = ProhibitedNode(node, reason)
  91         return node
  92
  93     def _create_from_single_cap(self, cap):
  94         if isinstance(cap, uri.LiteralFileURI):
  95             return self._create_lit(cap)
  96         if isinstance(cap, uri.CHKFileURI):
  97             return self._create_immutable(cap)
  98         if isinstance(cap, uri.CHKFileVerifierURI):
  99             return self._create_immutable_verifier(cap)
 100         if isinstance(cap, (uri.ReadonlySSKFileURI, uri.WriteableSSKFileURI,
 101                             uri.WriteableMDMFFileURI, uri.ReadonlyMDMFFileURI)):
 102             return self._create_mutable(cap)
 103         if isinstance(cap, (uri.DirectoryURI,
 104                             uri.ReadonlyDirectoryURI,
 105                             uri.ImmutableDirectoryURI,
 106                             uri.LiteralDirectoryURI,
 107                             uri.MDMFDirectoryURI,
 108                             uri.ReadonlyMDMFDirectoryURI)):
 109             filenode = self._create_from_single_cap(cap.get_filenode_cap())
 110             return self._create_dirnode(filenode)
 111         return None
 112
 113     def create_mutable_file(self, contents=None, keysize=None, version=None):
 114         if version is None:
 115             version = self.mutable_file_default
 116         n = MutableFileNode(self.storage_broker, self.secret_holder,
 117                             self.default_encoding_parameters, self.history)
 118         d = self.key_generator.generate(keysize)
 119         d.addCallback(n.create_with_keys, contents, version=version)
 120         d.addCallback(lambda res: n)
 121         return d
 122
 123     def create_new_mutable_directory(self, initial_children={}, version=None):
 124         # initial_children must have metadata (i.e. {} instead of None)
 125         for (name, (node, metadata)) in initial_children.iteritems():
 126             precondition(isinstance(metadata, dict),
 127                          "create_new_mutable_directory requires metadata to be a dict, not None", metadata)
 128             node.raise_error()
 129         d = self.create_mutable_file(lambda n:
 130                                      MutableData(pack_children(initial_children,
 131                                                     n.get_writekey())),
 132                                      version=version)
 133         d.addCallback(self._create_dirnode)
 134         return d
 135
 136     def create_immutable_directory(self, children, convergence=None):
 137         if convergence is None:
 138             convergence = self.secret_holder.get_convergence_secret()
 139         packed = pack_children(children, None, deep_immutable=True)
 140         uploadable = Data(packed, convergence)
 141         d = self.uploader.upload(uploadable)
 142         d.addCallback(lambda results: self.create_from_cap(None, results.uri))
 143         d.addCallback(self._create_dirnode)
 144         return d