src/allmydata/immutable/filenode.py

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