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, MustBeDeepImmutableError
   5 from allmydata.immutable.filenode import ImmutableFileNode, LiteralFileNode
   6 from allmydata.immutable.upload import Data
   7 from allmydata.mutable.filenode import MutableFileNode
   8 from allmydata.dirnode import DirectoryNode, pack_children
   9 from allmydata.unknown import UnknownNode
  10 from allmydata import uri
  11
  12 class DummyImmutableFileNode:
  13     def get_writekey(self):
  14         return None
  15
  16 class NodeMaker:
  17     implements(INodeMaker)
  18
  19     def __init__(self, storage_broker, secret_holder, history,
  20                  uploader, downloader, download_cache_dirman,
  21                  default_encoding_parameters, key_generator):
  22         self.storage_broker = storage_broker
  23         self.secret_holder = secret_holder
  24         self.history = history
  25         self.uploader = uploader
  26         self.downloader = downloader
  27         self.download_cache_dirman = download_cache_dirman
  28         self.default_encoding_parameters = default_encoding_parameters
  29         self.key_generator = key_generator
  30
  31         self._node_cache = weakref.WeakValueDictionary() # uri -> node
  32
  33     def _create_lit(self, cap):
  34         return LiteralFileNode(cap)
  35     def _create_immutable(self, cap):
  36         return ImmutableFileNode(cap, self.storage_broker, self.secret_holder,
  37                                  self.downloader, self.history,
  38                                  self.download_cache_dirman)
  39     def _create_mutable(self, cap):
  40         n = MutableFileNode(self.storage_broker, self.secret_holder,
  41                             self.default_encoding_parameters,
  42                             self.history)
  43         return n.init_from_cap(cap)
  44     def _create_dirnode(self, filenode):
  45         return DirectoryNode(filenode, self, self.uploader)
  46
  47     def create_from_cap(self, writecap, readcap=None, deep_immutable=False, name=u"<unknown name>"):
  48         # this returns synchronously. It starts with a "cap string".
  49         assert isinstance(writecap, (str, type(None))), type(writecap)
  50         assert isinstance(readcap,  (str, type(None))), type(readcap)
  51
  52         bigcap = writecap or readcap
  53         if not bigcap:
  54             # maybe the writecap was hidden because we're in a readonly
  55             # directory, and the future cap format doesn't have a readcap, or
  56             # something.
  57             return UnknownNode(None, None)  # deep_immutable and name not needed
  58
  59         # The name doesn't matter for caching since it's only used in the error
  60         # attribute of an UnknownNode, and we don't cache those.
  61         memokey = ("I" if deep_immutable else "M") + bigcap
  62         if memokey in self._node_cache:
  63             return self._node_cache[memokey]
  64         cap = uri.from_string(bigcap, deep_immutable=deep_immutable, name=name)
  65         node = self._create_from_single_cap(cap)
  66         if node:
  67             self._node_cache[memokey] = node  # note: WeakValueDictionary
  68         else:
  69             # don't cache UnknownNode
  70             node = UnknownNode(writecap, readcap, deep_immutable=deep_immutable, name=name)
  71         return node
  72
  73     def _create_from_single_cap(self, cap):
  74         if isinstance(cap, uri.LiteralFileURI):
  75             return self._create_lit(cap)
  76         if isinstance(cap, uri.CHKFileURI):
  77             return self._create_immutable(cap)
  78         if isinstance(cap, (uri.ReadonlySSKFileURI, uri.WriteableSSKFileURI)):
  79             return self._create_mutable(cap)
  80         if isinstance(cap, (uri.DirectoryURI,
  81                             uri.ReadonlyDirectoryURI,
  82                             uri.ImmutableDirectoryURI,
  83                             uri.LiteralDirectoryURI)):
  84             filenode = self._create_from_single_cap(cap.get_filenode_cap())
  85             return self._create_dirnode(filenode)
  86         return None
  87
  88     def create_mutable_file(self, contents=None, keysize=None):
  89         n = MutableFileNode(self.storage_broker, self.secret_holder,
  90                             self.default_encoding_parameters, self.history)
  91         d = self.key_generator.generate(keysize)
  92         d.addCallback(n.create_with_keys, contents)
  93         d.addCallback(lambda res: n)
  94         return d
  95
  96     def create_new_mutable_directory(self, initial_children={}):
  97         # initial_children must have metadata (i.e. {} instead of None)
  98         for (name, (node, metadata)) in initial_children.iteritems():
  99             precondition(isinstance(metadata, dict),
 100                          "create_new_mutable_directory requires metadata to be a dict, not None", metadata)
 101             node.raise_error()
 102         d = self.create_mutable_file(lambda n:
 103                                      pack_children(n, initial_children))
 104         d.addCallback(self._create_dirnode)
 105         return d
 106
 107     def create_immutable_directory(self, children, convergence=None):
 108         if convergence is None:
 109             convergence = self.secret_holder.get_convergence_secret()
 110         for (name, (node, metadata)) in children.iteritems():
 111             precondition(isinstance(metadata, dict),
 112                          "create_immutable_directory requires metadata to be a dict, not None", metadata)
 113             node.raise_error()
 114             if not node.is_allowed_in_immutable_directory():
 115                 raise MustBeDeepImmutableError("%s is not immutable" % (node,), name)
 116         n = DummyImmutableFileNode() # writekey=None
 117         packed = pack_children(n, children)
 118         uploadable = Data(packed, convergence)
 119         d = self.uploader.upload(uploadable, history=self.history)
 120         d.addCallback(lambda results: self.create_from_cap(None, results.uri))
 121         d.addCallback(self._create_dirnode)
 122         return d