src/allmydata/immutable/filenode.py

   1
   2 from zope.interface import implements
   3 from twisted.internet import defer
   4 from twisted.internet.interfaces import IPushProducer, IConsumer
   5 from allmydata.interfaces import IFileNode, IFileURI, ICheckable
   6 from allmydata.immutable.checker import SimpleCHKFileChecker, \
   7      SimpleCHKFileVerifier
   8
   9 class ImmutableFileNode(object):
  10     implements(IFileNode, ICheckable)
  11     checker_class = SimpleCHKFileChecker
  12     verifier_class = SimpleCHKFileVerifier
  13
  14     def __init__(self, uri, client):
  15         self.u = IFileURI(uri)
  16         self._client = client
  17
  18     def get_readonly_uri(self):
  19         return self.get_uri()
  20
  21     def is_mutable(self):
  22         return False
  23
  24     def is_readonly(self):
  25         return True
  26
  27     def __hash__(self):
  28         return self.u.__hash__()
  29     def __eq__(self, other):
  30         if IFileNode.providedBy(other):
  31             return self.u.__eq__(other.u)
  32         else:
  33             return False
  34     def __ne__(self, other):
  35         if IFileNode.providedBy(other):
  36             return self.u.__eq__(other.u)
  37         else:
  38             return True
  39
  40 class FileNode(ImmutableFileNode):
  41     checker_class = SimpleCHKFileChecker
  42
  43     def __init__(self, uri, client):
  44         ImmutableFileNode.__init__(self, uri, client)
  45
  46     def get_uri(self):
  47         return self.u.to_string()
  48
  49     def get_size(self):
  50         return self.u.get_size()
  51
  52     def get_verifier(self):
  53         return self.u.get_verifier()
  54
  55     def get_storage_index(self):
  56         return self.u.storage_index
  57
  58     def check(self, monitor, verify=False):
  59         # TODO: pass the Monitor to SimpleCHKFileChecker or
  60         # SimpleCHKFileVerifier, have it call monitor.raise_if_cancelled()
  61         # before sending each request.
  62         storage_index = self.u.storage_index
  63         k = self.u.needed_shares
  64         N = self.u.total_shares
  65         size = self.u.size
  66         ueb_hash = self.u.uri_extension_hash
  67         if verify:
  68             v = self.verifier_class(self._client,
  69                                     storage_index, k, N, size, ueb_hash)
  70         else:
  71             v = self.checker_class(self._client, storage_index, k, N)
  72         return v.start()
  73
  74     def check_and_repair(self, monitor, verify=False):
  75         # this is a stub, to allow the deep-check tests to pass.
  76         #raise NotImplementedError("not implemented yet")
  77         from allmydata.checker_results import CheckAndRepairResults
  78         cr = CheckAndRepairResults(self.u.storage_index)
  79         d = self.check(verify)
  80         def _done(r):
  81             cr.pre_repair_results = cr.post_repair_results = r
  82             cr.repair_attempted = False
  83             return cr
  84         d.addCallback(_done)
  85         return d
  86
  87     def download(self, target):
  88         downloader = self._client.getServiceNamed("downloader")
  89         return downloader.download(self.get_uri(), target)
  90
  91     def download_to_data(self):
  92         downloader = self._client.getServiceNamed("downloader")
  93         return downloader.download_to_data(self.get_uri())
  94
  95 class LiteralProducer:
  96     implements(IPushProducer)
  97     def resumeProducing(self):
  98         pass
  99     def stopProducing(self):
 100         pass
 101
 102 class LiteralFileNode(ImmutableFileNode):
 103
 104     def __init__(self, uri, client):
 105         ImmutableFileNode.__init__(self, uri, client)
 106
 107     def get_uri(self):
 108         return self.u.to_string()
 109
 110     def get_size(self):
 111         return len(self.u.data)
 112
 113     def get_verifier(self):
 114         return None
 115
 116     def get_storage_index(self):
 117         return None
 118
 119     def check(self, monitor, verify=False):
 120         return defer.succeed(None)
 121
 122     def check_and_repair(self, monitor, verify=False):
 123         return defer.succeed(None)
 124
 125     def download(self, target):
 126         # note that this does not update the stats_provider
 127         data = self.u.data
 128         if IConsumer.providedBy(target):
 129             target.registerProducer(LiteralProducer(), True)
 130         target.open(len(data))
 131         target.write(data)
 132         if IConsumer.providedBy(target):
 133             target.unregisterProducer()
 134         target.close()
 135         return defer.maybeDeferred(target.finish)
 136
 137     def download_to_data(self):
 138         data = self.u.data
 139         return defer.succeed(data)