def test_other_types():
comp = b'\x09\x039\x3dA'
assert Component.to_str(comp) == "9=9%3DA"
assert Component.from_str('9%3DA') != comp
assert Component.from_str('9=9%3DA') == comp
comp = bytes.fromhex('FDFFFF00')
assert Component.get_type(comp) == 0xffff
assert Component.to_str(comp) == '65535='
comp = bytearray.fromhex('FD576501 2E')
assert Component.get_type(comp) == 0x5765
assert Component.to_str(comp) == '22373=.'
def on_interest(int_name, _int_param, _app_param):
if Component.get_type(int_name[-1]) == Component.TYPE_SEGMENT:
seg_no = Component.to_number(int_name[-1])
else:
seg_no = 0
if seg_no < seg_cnt:
app.put_raw_packet(packets[seg_no])
def test_generic():
comp = b'\x08\x0andn-python'
assert Component.get_type(comp) == Component.TYPE_GENERIC
assert Component.to_str(comp) == 'ndn-python'
assert Component.from_str('ndn-python') == comp
assert Component.from_str('8=ndn-python') == comp
comp = b"\x08\x07foo%bar"
assert Component.to_str(comp) == "foo%25bar"
assert Component.from_str('foo%25bar') == comp
assert Component.from_str('8=foo%25bar') == comp
comp = b'\x08\x04-._~'
assert Component.to_str(comp) == "-._~"
assert Component.from_str('-._~') == comp
assert Component.from_str('8=-._~') == comp
with pytest.raises(ValueError):
Component.from_str(":/?#[]@")
comp = Component.from_bytes(b':/?#[]@')
assert Component.to_str(comp) == "%3A%2F%3F%23%5B%5D%40"
assert Component.from_str("%3a%2f%3f%23%5b%5d%40") == comp
with pytest.raises(ValueError):
Component.from_str("/")
assert Component.from_str('') == b'\x08\x00'
assert Component.from_bytes(b'') == b'\x08\x00'
def on_interest(self, name: FormalName, _param: InterestParam, _app_param: typing.Optional[BinaryStr]):
# Get the name and segment number
if Component.get_type(name[-1]) == Component.TYPE_SEGMENT:
obj_name = Component.get_value(name[-2])
seg_no = Component.to_number(name[-1])
else:
obj_name = Component.get_value(name[-1])
seg_no = 0
# Read the data
# Git objects are small so we can read the whole object
try:
obj_type, data = self.repo.read_obj(bytes(obj_name))
except ValueError:
logging.warning(f'Requested file {obj_name} does not exist in repo {self.repo.repo_name}')
return
# Extract the segment and calculate Name
data_name = self.prefix + [Component.from_bytes(obj_name), Component.from_segment(seg_no)]
start_pos = seg_no * SEGMENTATION_SIZE
data_seg = data[start_pos:start_pos + SEGMENTATION_SIZE]
packet_obj = SyncObject()
packet_obj.obj_type = obj_type.encode()
packet_obj.obj_data = data_seg
wire = packet_obj.encode()
final_block = (len(data) + SEGMENTATION_SIZE - 1) // SEGMENTATION_SIZE
self.app.put_data(data_name, wire,
freshness_period=3600000,
final_block_id=Component.from_segment(final_block))
logging.debug(f'Responded {obj_name} segment {final_block} in repo {self.repo.repo_name}')
def sha256_tester(typ, uri_prefix):
hex_text = '%28%ba%d4%b5%27%5b%d3%92%db%b6%70%c7%5c%f0%b6%6f%13%f7%94%2b%21%e8%0f%55%c0%e8%6b%37%47%53%a5%48'
hex_lower = ''.join(hex_text.split('%'))
hex_upper = hex_lower.upper()
comp = Component.from_bytes(bytes.fromhex(hex_upper), typ=typ)
assert Component.get_type(comp) == typ
assert Component.to_str(comp) == uri_prefix + hex_lower
assert Component.from_str(uri_prefix + hex_lower) == comp
assert Component.from_str(uri_prefix + hex_upper) == comp
def test_number():
assert Component.from_segment(13) == b'!\x01\r'
assert Component.from_byte_offset(13) == b'\x22\x01\r'
assert Component.from_sequence_num(13) == b'%\x01\r'
assert Component.from_version(13) == b'#\x01\r'
timeval = 15686790223318112
comp = Component.from_timestamp(timeval)
assert Component.get_type(comp) == 36
assert Component.get_value(comp) == b'\x00\x37\xbb\x0d\x76\xed\x4c\x60'
assert Component.to_number(comp) == timeval
def on_interest(inst_name: FormalName, inst_param: InterestParam,
app_param: BinaryStr):
d = json.loads(app_param.tobytes().decode())
enc_session_key = base64.b64decode(d['enc_session_key'])
nonce = base64.b64decode(d['nonce'])
if Component.get_type(inst_name[-1]) == Component.TYPE_SEGMENT:
seg_no = Component.to_number(inst_name[-1])
else:
seg_no = 0
if seg_no < seg_cnt:
app.put_data(inst_name,
packets[seg_no],
final_block_id=Component.from_segment(seg_cnt - 1),
freshness_period=10000)
def test_basic_encode():
uri = ('/Emid/25042=P3//./%1C%9F'
'/sha256digest=0415e3624a151850ac686c84f155f29808c0dd73819aa4a4c20be73a4d8a874c')
name = Name.from_str(uri)
assert len(name) == 6
assert name[0] == Component.from_bytes(b'Emid')
assert name[1] == b'\xfd\x61\xd2\x02\x50\x33'
assert name[2] == Component.from_bytes(b'')
assert name[3] == Component.from_bytes(b'.')
assert name[4] == Component.from_bytes(b'\x1C\x9F')
assert Component.get_type(name[5]) == Component.TYPE_IMPLICIT_SHA256
assert Name.encoded_length(name) == 57
assert (Name.encode(name) ==
b'\x07\x37\x08\x04Emid\xfda\xd2\x02P3\x08\x00\x08\x01.\x08\x02\x1c\x9f'
b'\x01 \x04\x15\xe3bJ\x15\x18P\xachl\x84\xf1U\xf2\x98\x08\xc0\xdds\x81'
b'\x9a\xa4\xa4\xc2\x0b\xe7:M\x8a\x87L')
def test_number():
assert Component.from_segment(13) == b'!\x01\r'
assert Component.from_byte_offset(13) == b'\x22\x01\r'
assert Component.from_sequence_num(13) == b'%\x01\r'
assert Component.from_version(13) == b'#\x01\r'
timeval = 15686790223318112
comp = Component.from_timestamp(timeval)
assert Component.get_type(comp) == 36
assert Component.get_value(comp) == b'\x00\x37\xbb\x0d\x76\xed\x4c\x60'
assert Component.to_number(comp) == timeval
assert Component.to_str(Component.from_segment(13)) == 'seg=13'
assert Component.to_str(Component.from_byte_offset(13)) == 'off=13'
assert Component.to_str(Component.from_sequence_num(13)) == 'seq=13'
assert Component.to_str(Component.from_version(13)) == 'v=13'
assert Component.to_str(
Component.from_timestamp(timeval)) == 't=15686790223318112'
assert Component.from_str('seg=13') == b'!\x01\r'
assert Component.from_str('off=13') == b'\x22\x01\r'
assert Component.from_str('seq=13') == b'%\x01\r'
assert Component.from_str('v=13') == b'#\x01\r'
assert Component.from_str(
't=15686790223318112') == b'$\x08\x007\xbb\rv\xedL`'
async def segment_fetcher(app: NDNApp,
name: NonStrictName,
app_param: BinaryStr,
timeout=4000,
retry_times=3,
validator=None,
must_be_fresh=True):
"""
An async-generator to fetch a segmented object. Interests are issued one by one.
:param app: NDN Application
:param name: Name prefix of Data
:param timeout: Timeout value, in milliseconds
:param retry_times: Times for retry
:param validator: Validator
:param must_be_fresh: MustBeFresh field of Interest
:return: Data segments in order.
"""
async def retry(first):
nonlocal name
trial_times = 0
while True:
future = app.express_interest(name,
app_param=app_param,
validator=validator,
can_be_prefix=first,
must_be_fresh=must_be_fresh,
lifetime=timeout,
signer=None)
try:
return await future
except InterestTimeout:
trial_times += 1
if trial_times >= retry_times:
raise
name = Name.normalize(name)
# First Interest
name, meta, content = await retry(True)
name += [Component.from_segment(0)]
# If it's not segmented
if Component.get_type(name[-1]) != Component.TYPE_SEGMENT:
yield content
return
# If it's segmented
if Component.to_number(name[-1]) == 0:
yield content
if meta.final_block_id == name[-1]:
return
seg_no = 1
else:
# If it's not segment 0, starting from 0
seg_no = 0
# Following Interests
while True:
name[-1] = Component.from_segment(seg_no)
name, meta, content = await retry(False)
yield content
if meta.final_block_id == name[-1]:
return
seg_no += 1
