src/allmydata/codec.py

   1 # -*- test-case-name: allmydata.test.test_encode_share -*-
   2
   3 from zope.interface import implements
   4 from twisted.internet import defer
   5 from allmydata.util import mathutil
   6 from allmydata.util.assertutil import precondition
   7 from allmydata.interfaces import ICodecEncoder, ICodecDecoder
   8 import zfec
   9
  10 class CRSEncoder(object):
  11     implements(ICodecEncoder)
  12     ENCODER_TYPE = "crs"
  13
  14     def set_params(self, data_size, required_shares, max_shares):
  15         assert required_shares <= max_shares
  16         self.data_size = data_size
  17         self.required_shares = required_shares
  18         self.max_shares = max_shares
  19         self.share_size = mathutil.div_ceil(data_size, required_shares)
  20         self.last_share_padding = mathutil.pad_size(self.share_size, required_shares)
  21         self.encoder = zfec.Encoder(required_shares, max_shares)
  22
  23     def get_encoder_type(self):
  24         return self.ENCODER_TYPE
  25
  26     def get_params(self):
  27         return (self.data_size, self.required_shares, self.max_shares)
  28
  29     def get_serialized_params(self):
  30         return "%d-%d-%d" % (self.data_size, self.required_shares,
  31                              self.max_shares)
  32
  33     def get_block_size(self):
  34         return self.share_size
  35
  36     def encode(self, inshares, desired_share_ids=None):
  37         precondition(desired_share_ids is None or len(desired_share_ids) <= self.max_shares, desired_share_ids, self.max_shares)
  38
  39         if desired_share_ids is None:
  40             desired_share_ids = range(self.max_shares)
  41
  42         for inshare in inshares:
  43             assert len(inshare) == self.share_size, (len(inshare), self.share_size, self.data_size, self.required_shares)
  44         shares = self.encoder.encode(inshares, desired_share_ids)
  45
  46         return defer.succeed((shares, desired_share_ids))
  47
  48 class CRSDecoder(object):
  49     implements(ICodecDecoder)
  50
  51     def set_params(self, data_size, required_shares, max_shares):
  52         self.data_size = data_size
  53         self.required_shares = required_shares
  54         self.max_shares = max_shares
  55
  56         self.chunk_size = self.required_shares
  57         self.num_chunks = mathutil.div_ceil(self.data_size, self.chunk_size)
  58         self.share_size = self.num_chunks
  59         self.decoder = zfec.Decoder(self.required_shares, self.max_shares)
  60
  61     def get_needed_shares(self):
  62         return self.required_shares
  63
  64     def decode(self, some_shares, their_shareids):
  65         precondition(len(some_shares) == len(their_shareids),
  66                      len(some_shares), len(their_shareids))
  67         precondition(len(some_shares) == self.required_shares,
  68                      len(some_shares), self.required_shares)
  69         data = self.decoder.decode(some_shares,
  70                                    [int(s) for s in their_shareids])
  71         return defer.succeed(data)
  72
  73 def parse_params(serializedparams):
  74     pieces = serializedparams.split("-")
  75     return int(pieces[0]), int(pieces[1]), int(pieces[2])