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)