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 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])
async def get_last_frame(device_name):
"""
Get the last frame number from interest /device/1080p/metadata/timestamp
"""
message_counter = 0
while message_counter < 100:
try:
timestamp = ndn.utils.timestamp()
name = Name.from_str('/{}/1080p/metadata/'.format(device_name)) + [
Component.from_timestamp(timestamp)
]
print(
f'Sending Interest {Name.to_str(name)}, {InterestParam(must_be_fresh=False, lifetime=600)}'
)
data_name, meta_info, content = await app.express_interest(
name, must_be_fresh=False, can_be_prefix=True, lifetime=2000)
print(f'Received Data Name: {Name.to_str(data_name)}')
ct = bytes(content)
last_frame_name = Name.from_str(str(ct)[2:-1])
print("Last Frame number ", Name.to_str(last_frame_name))
last_frame_num = Component.to_number(last_frame_name[-1])
return last_frame_num
except InterestNack as e:
print(f'Nacked with reason={e.reason}')
except InterestTimeout:
print(f'Timeout')
except InterestCanceled:
print(f'Canceled')
except ValidationFailure:
print(f'Data failed to validate')
message_counter += 1
def _on_interest(self, int_name, _int_param, _app_param):
# use segment number to index into the encoded packets array
logging.info(f'On interest: {Name.to_str(int_name)}')
seq = Component.to_number(int_name[-1])
if seq >= 0 and seq < len(self.encoded_packets):
self.app.put_raw_packet(self.encoded_packets[seq])
logging.info(f'Serve data: {Name.to_str(int_name)}')
else:
logging.info(f'Data does not exist: {Name.to_str(int_name)}')
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
async def onPropInterestHelper(self, int_name: FormalName,
int_param: InterestParam,
_app_param: Optional[BinaryStr],
sig_ptrs: SignaturePtrs) -> None:
sv = bytes(self.table.getPart(Component.to_number(int_name[-1])))
SVSyncLogger.info(f'SVSyncBalancer: sending balance {sv}')
self.app.put_data(int_name,
content=sv,
signer=self.secOptions.dataSig.signer,
freshness_period=self.PROP_PACKET_FRESHNESS)
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)
async def _retry(seq: int):
"""
Retry 3 times fetching data of the given sequence number or fail.
:param seq: block_id of data
"""
nonlocal app, name, semaphore, is_failed, received_or_fail, final_id
int_name = name[:]
int_name.append(str(seq))
trial_times = 0
while True:
trial_times += 1
if trial_times > 3:
semaphore.release()
is_failed = True
received_or_fail.set()
return
try:
print(datetime.now().strftime("%H:%M:%S.%f "), end='')
print('Express Interest: {}'.format(Name.to_str(int_name)))
# Get the data name first, and then use the name to get the entire packet value (including sig). This
# is necessary because express_interest() does not return the sig, which is needed by the repo. An
# additional decoding step is necessary to obtain the metadata.
data_name, _, _ = await app.express_interest(
int_name,
must_be_fresh=True,
can_be_prefix=False,
lifetime=1000)
data_bytes = app.get_original_packet_value(data_name)
(_, meta_info, content,
sig) = ndn_format_0_3.parse_data(data_bytes, with_tl=False)
# Save data and update final_id
print(datetime.now().strftime("%H:%M:%S.%f "), end='')
print('Received data: {}'.format(Name.to_str(data_name)))
seq_to_data_packet[seq] = data_bytes
if meta_info is not None and meta_info.final_block_id is not None:
final_id = Component.to_number(meta_info.final_block_id)
break
except InterestNack as e:
print(f'Nacked with reason={e.reason}')
except InterestTimeout:
print(f'Timeout')
semaphore.release()
received_or_fail.set()
async def face_event(self):
last_seq = -1
name_prefix = Name.from_str('/localhost/nfd/faces/events')
while True:
if last_seq >= 0:
name = name_prefix + [
Component.from_sequence_num(last_seq + 1)
]
init = False
else:
name = name_prefix
init = True
logging.info("Face event notification stream %s",
Name.to_str(name))
try:
data_name, _, content = await self.app.express_interest(
name,
must_be_fresh=init,
can_be_prefix=init,
lifetime=60000)
last_seq = Component.to_number(data_name[-1])
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if not content:
print('ERROR: Face event is empty')
elif content[0] == 0x65:
msg = parse_response(content)
print('Query failed with response', msg['status_code'],
msg['status_text'])
else:
dic = self.face_event_to_dict(content)
dic['seq'] = str(last_seq)
dic['time'] = timestamp
await self.emit('face event', dic)
self.event_list.append(dic)
except (InterestCanceled, NetworkError):
break
except InterestTimeout:
last_seq = -1
except InterestNack as e:
print(f'Face events nacked with reason={e.reason}')
last_seq = -1
except ValidationFailure:
print('Face events failed to validate')
last_seq = -1
await asyncio.sleep(0.1)
async def _retry(seq: int):
"""
Retry 3 times fetching data of the given sequence number or fail.
:param seq: block_id of data
"""
nonlocal app, name, semaphore, is_failed, received_or_fail, final_id
int_name = name + [Component.from_segment(seq)]
trial_times = 0
while True:
trial_times += 1
if trial_times > 3:
semaphore.release()
is_failed = True
received_or_fail.set()
return
try:
logging.info('Express Interest: {}'.format(
Name.to_str(int_name)))
data_name, meta_info, content, data_bytes = await app.express_interest(
int_name,
need_raw_packet=True,
must_be_fresh=False,
can_be_prefix=False,
lifetime=1000,
**kwargs)
# Save data and update final_id
logging.info('Received data: {}'.format(
Name.to_str(data_name)))
seq_to_data_packet[seq] = (data_name, meta_info, content,
data_bytes)
if meta_info is not None and meta_info.final_block_id is not None:
final_id = Component.to_number(meta_info.final_block_id)
break
except InterestNack as e:
logging.info(f'Nacked with reason={e.reason}')
except InterestTimeout:
logging.info(f'Timeout')
semaphore.release()
received_or_fail.set()
async def main(app: NDNApp) -> int:
try:
source = Component.from_number(6, Component.TYPE_SEQUENCE_NUM)
print(source)
print(Component.to_number(source))
"""
name = Name.from_str("/b")*2928
interest = make_interest(name, InterestParam(can_be_prefix=True, must_be_fresh=True, lifetime=6000))
print(f'size: {len(interest)}')
_, _, _, pkt = await app.express_interest(interest)
data_name, meta_info, content, sig_ptrs = parse_data(pkt)
content = content if content else bytes("NONE")
print(f'CONTENT: {bytes(content).decode()}')
print(f'CONTENT-TYPE: {meta_info.content_type}')
"""
except (InterestNack, InterestTimeout, InterestCanceled,
ValidationFailure) as e:
print(f'Nacked with reason={e.reason}')
finally:
app.shutdown()
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
async def onStateInterestHelper(self, int_name:FormalName, int_param:InterestParam, _app_param:Optional[BinaryStr], sig_ptrs:SignaturePtrs) -> None:
sv = bytes(self.table.getPart(Component.to_number(int_name[-1])))
logging.info(f'MSBalancer: sending balance {sv}')
self.app.put_data(int_name, content=sv, freshness_period=1000)
