def decode(self, segments, segment_numbers, padding_size):
"""
segments
a list of num_segments strings each containing concatenated
encoded blocks
segment_numbers
a list of ints giving the segment nimbers of the segments (1..n)
padding_size
the zfec padding size of the last block (earlier blocks are 0)
"""
data_list = list()
slice_count = _slice_count(len(segments[0]), encoded_block_slice_size)
slicegens = [
_slice_generator(s, encoded_block_slice_size) for s in segments
]
decoder = Decoder(self.min_segments, self.num_segments)
zfec_segment_numbers = [n-1 for n in segment_numbers]
# accumulate all but the last slice with padding set to 0
for _ in range(slice_count-1):
encoded_blocks = [slicegen.next() for slicegen in slicegens]
data_list.append(
decoder.decode(encoded_blocks, zfec_segment_numbers, 0)
)
# accumulate the last slice using the padding size
encoded_blocks = [slicegen.next() for slicegen in slicegens]
data_list.append(
decoder.decode(encoded_blocks, zfec_segment_numbers, padding_size)
)
return "".join(data_list)
def decode(self, segments, segment_numbers, padding_size):
"""
segments
a list size=num_segments of lists of encoded blocks (zfec shares)
segment_numbers
a list of ints giving the segment numbers of the segments (1..n)
padding_size
the zfec padding size of the last block (earlier blocks are 0)
return
a list of data blocks
"""
data_list = list()
decoder = Decoder(self.min_segments, self.num_segments)
zfec_segment_numbers = [n-1 for n in segment_numbers]
# accumulate all but the last slice with padding set to 0
for i in range(len(segments[0])-1):
encoded_blocks = [segment[i] for segment in segments]
data_list.append(
decoder.decode(encoded_blocks, zfec_segment_numbers, 0)
)
# accumulate the last slice using the padding size
encoded_blocks = [segment[-1] for segment in segments]
data_list.append(
decoder.decode(encoded_blocks, zfec_segment_numbers, padding_size)
)
return data_list
def _handle_zfec_decode(request, request_data):
log = logging.getLogger("_handle_zfec_decode")
decoder = Decoder(_min_segments, _num_segments)
zfec_segment_numbers = [n-1 for n in request["segment-numbers"]]
decoded_block = decoder.decode(request_data,
zfec_segment_numbers,
request["padding-size"])
reply = {
"message-type" : "zfec-decode-reply",
"result" : "success",
"error-message" : ""
}
log.debug("decode to {0} bytes".format(len(decoded_block)))
return reply, [decoded_block, ]
def _handle_zfec_decode(request, request_data):
log = logging.getLogger("_handle_zfec_decode")
decoder = Decoder(_min_segments, _num_segments)
zfec_segment_numbers = [n - 1 for n in request["segment-numbers"]]
decoded_block = decoder.decode(request_data, zfec_segment_numbers,
request["padding-size"])
reply = {
"message-type": "zfec-decode-reply",
"result": "success",
"error-message": ""
}
log.debug("decode to {0} bytes".format(len(decoded_block)))
return reply, [
decoded_block,
]
def _handle_zfec_rebuild_encoded_shares(request, request_data):
log = logging.getLogger("_handle_zfec_rebuild_encoded_shares")
# first decode the good segments into the original data
decoder = Decoder(_min_segments, _num_segments)
zfec_segment_numbers = [n-1 for n in request["segment-numbers"]]
decoded_block = decoder.decode(request_data,
zfec_segment_numbers,
request["padding-size"])
# now re-encode the block to get the missing segments
encoder = Encoder(_min_segments, _num_segments)
result_list = encoder.encode(decoded_block)
reply = {
"message-type" : "zfec-rebuild-encoded-shares-reply",
"rebuilt-segment-numbers" : request["needed-segment-numbers"],
"result" : "success",
"error-message" : ""
}
log.debug("rebuilt {0}".format(reply["rebuilt-segment-numbers"]))
return reply, [result_list[n-1] for n in request["needed-segment-numbers"]]
def _handle_zfec_rebuild_encoded_shares(request, request_data):
log = logging.getLogger("_handle_zfec_rebuild_encoded_shares")
# first decode the good segments into the original data
decoder = Decoder(_min_segments, _num_segments)
zfec_segment_numbers = [n - 1 for n in request["segment-numbers"]]
decoded_block = decoder.decode(request_data, zfec_segment_numbers,
request["padding-size"])
# now re-encode the block to get the missing segments
encoder = Encoder(_min_segments, _num_segments)
result_list = encoder.encode(decoded_block)
reply = {
"message-type": "zfec-rebuild-encoded-shares-reply",
"rebuilt-segment-numbers": request["needed-segment-numbers"],
"result": "success",
"error-message": ""
}
log.debug("rebuilt {0}".format(reply["rebuilt-segment-numbers"]))
return reply, [
result_list[n - 1] for n in request["needed-segment-numbers"]
]
