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, IURI, ICheckable
   5 from allmydata import uri
   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, verify=False):
  59         storage_index = self.u.storage_index
  60         k = self.u.needed_shares
  61         N = self.u.total_shares
  62         size = self.u.size
  63         ueb_hash = self.u.uri_extension_hash
  64         if verify:
  65             v = self.verifier_class(self._client,
  66                                     storage_index, k, N, size, ueb_hash)
  67         else:
  68             v = self.checker_class(self._client, storage_index, k, N)
  69         return v.start()
  70
  71     def check_and_repair(self, verify=False):
  72         # this is a stub, to allow the deep-check tests to pass.
  73         #raise NotImplementedError("not implemented yet")
  74         from allmydata.checker_results import CheckAndRepairResults
  75         cr = CheckAndRepairResults(self.u.storage_index)
  76         d = self.check(verify)
  77         def _done(r):
  78             cr.pre_repair_results = cr.post_repair_results = r
  79             cr.repair_attempted = False
  80             return cr
  81         d.addCallback(_done)
  82         return d
  83
  84     def download(self, target):
  85         downloader = self._client.getServiceNamed("downloader")
  86         return downloader.download(self.get_uri(), target)
  87
  88     def download_to_data(self):
  89         downloader = self._client.getServiceNamed("downloader")
  90         return downloader.download_to_data(self.get_uri())
  91
  92
  93
  94 class LiteralFileNode(ImmutableFileNode):
  95
  96     def __init__(self, uri, client):
  97         ImmutableFileNode.__init__(self, uri, client)
  98
  99     def get_uri(self):
 100         return self.u.to_string()
 101
 102     def get_size(self):
 103         return len(self.u.data)
 104
 105     def get_verifier(self):
 106         return None
 107
 108     def get_storage_index(self):
 109         return None
 110
 111     def check(self, verify=False):
 112         # neither verify= nor repair= affect LIT files, and the check returns
 113         # no results.
 114         return defer.succeed(None)
 115
 116     def check_and_repair(self, verify=False):
 117         return defer.succeed(None)
 118
 119     def download(self, target):
 120         # note that this does not update the stats_provider
 121         data = self.u.data
 122         target.open(len(data))
 123         target.write(data)
 124         target.close()
 125         return defer.maybeDeferred(target.finish)
 126
 127     def download_to_data(self):
 128         data = self.u.data
 129         return defer.succeed(data)