def __init__(self, app: NDNApp, repo: repos.GitRepo, pipeline: RepoSyncPipeline): self.app = app self.repo = repo self.pipeline = pipeline self.prefix = Name.from_str(os.getenv("GIT_NDN_PREFIX") + f'/project/{repo.repo_name}') aio.create_task(self.app.register(self.prefix + [Component.from_str('ref-list')], self.ref_list)) aio.create_task(self.app.register(self.prefix + [Component.from_str('push')], self.push))
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 __init__(self, app: NDNApp, groupPrefix: Name, nid: Name, updateCallback: Callable, storage: Optional[Storage] = None, securityOptions: Optional[SecurityOptions] = None) -> None: preSyncPrefix, preDataPrefix = groupPrefix + [ Component.from_str("sync") ], nid + groupPrefix + [Component.from_str("data")] super().__init__(app, preSyncPrefix, preDataPrefix, groupPrefix, nid, updateCallback, storage, securityOptions)
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 test_compare(): comps = [ Component.from_hex('0000000000000000000000000000000000000000000000000000000000000000', 1), Component.from_hex('0000000000000000000000000000000000000000000000000000000000000001', 1), Component.from_hex('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', 1), Component.from_hex('0000000000000000000000000000000000000000000000000000000000000000', 2), Component.from_hex('0000000000000000000000000000000000000000000000000000000000000001', 2), Component.from_hex('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', 2), Component.from_bytes(b'', 0x03), Component.from_bytes(b'\x44', 0x03), Component.from_bytes(b'\x46', 0x03), Component.from_bytes(b'\x41\x41', 0x03), Component.from_str(''), Component.from_str('D'), Component.from_str('F'), Component.from_str('AA'), Component.from_str('21426='), Component.from_str('21426=%44'), Component.from_str('21426=%46'), Component.from_str('21426=%41%41') ] for i, lhs in enumerate(comps): for j, rhs in enumerate(comps): assert (lhs == rhs) == (i == j) assert (lhs != rhs) == (i != j) assert (lhs < rhs) == (i < j) assert (lhs <= rhs) == (i <= j) assert (lhs > rhs) == (i > j) assert (lhs >= rhs) == (i >= j)
def __init__(self, app: NDNApp, groupPrefix: Name, nid: Name, updateCallback: Callable, cacheOthers: bool, storage: Optional[Storage] = None, securityOptions: Optional[SecurityOptions] = None) -> None: self.cacheOthers = cacheOthers preDataPrefix = groupPrefix + [ Component.from_str("data") ] if self.cacheOthers else groupPrefix + [Component.from_str("data") ] + nid preSyncPrefix = groupPrefix + [Component.from_str("sync")] super().__init__(app, preSyncPrefix, preDataPrefix, groupPrefix, nid, updateCallback, storage, securityOptions)
def test_basic(self): class Model(TlvModel): name = NameField() int_val = UintField(0x03) str_val = BytesField(0x02) bool_val = BoolField(0x01) model = Model() model.name = ['test', Component.from_str('name')] model.int_val = 0 assert model.encode() == b'\x07\x0c\x08\x04test\x08\x04name\x03\x01\x00' model = Model.parse(b'\x07\x0c\x08\x04test\x08\x04name\x03\x01\x00') assert model.name == Name.from_str('/test/name') assert model.int_val == 0 assert not model.bool_val model.name = 'test/name' model.str_val = b'str' model.bool_val = True assert model.encode() == b'\x07\x0c\x08\x04test\x08\x04name\x03\x01\x00\x02\x03str\x01\x00' model = Model.parse(b'\x07\x0c\x08\x04test\x08\x04name\x03\x01\x00\x02\x03str\x01\x00') assert model.str_val == b'str' assert model.bool_val
def __init__(self, app: NDNApp, command_client: CommandClient, node_name: NonStrictName, repo_prefix: NonStrictName): self.app = app self.command_client = command_client self.node_name = node_name self.repo_prefix = repo_prefix node_name_name = Name.normalize(self.node_name) self.node_prefix = Name.normalize(self.repo_prefix) self.node_prefix.extend(node_name_name) self.node_recall_prefix = self.node_prefix self.node_recall_prefix.append(Component.from_str('recall'))
def main(): parser = argparse.ArgumentParser(description='python client.py') parser.add_argument('-n', '--node_prefix', required=True, help='Prefix of catalog ("/217B/repo/node/A")') parser.add_argument('-c', '--command', default='insert', choices=['insert', 'delete', 'recall'], help='Command Verb') parser.add_argument('-d', '--data_name', required=True, help='data name ("/foo/bar/1.txt")') parser.add_argument('-s', '--hash', required=True, help='data hash ("1bd109fe")') parser.add_argument('-o', '--desired_copies', type=int, default=3, help='desired copies') args = parser.parse_args() logging.basicConfig(format='[%(asctime)s]%(levelname)s:%(message)s', datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO) app = NDNApp(face=None, keychain=KeychainDigest()) name = Name.from_str(args.node_prefix) name.append(Component.from_str(args.command)) datainfo_tlv_model = DatainfoTlvModel() datainfo_tlv_model.data_name = args.data_name.encode() datainfo_tlv_model.hash = args.hash.encode() datainfo_tlv_model.desired_copies = args.desired_copies datainfo_name_component = Component.from_bytes(datainfo_tlv_model.encode()) name.append(datainfo_name_component) # logging.info(name) try: app.run_forever(after_start=send(app, name)) except FileNotFoundError: logging.error('Error: could not connect to NFD.\n') return 0
def __init__(self, app: NDNApp, groupPrefix: Name, nid: Name, table: StateTable, updateCallback: Callable, secOptions: SecurityOptions) -> None: SVSyncLogger.info("SVSyncBalancer: started svsync balancer") self.app, self.groupPrefix, self.nid, self.table, self.updateCallback, self.secOptions, self.busy = app, groupPrefix, nid, table, updateCallback, secOptions, False self.propPrefix = self.nid + self.groupPrefix + [ Component.from_str("prop") ] self.taskWindow = AsyncWindow(self.PROP_WINDOW) self.app.route(self.propPrefix, need_sig_ptrs=True)(self.onPropInterest) SVSyncLogger.info( f'SVSyncBalancer: started listening to {Name.to_str(self.propPrefix)}' )
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 sendPropInterest(self, source: Name, pckno: int) -> Optional[StateVector]: name: Name = source + self.groupPrefix + [ Component.from_str("prop") ] + [Component.from_number(pckno, Component.TYPE_SEQUENCE_NUM)] try: SVSyncLogger.info( f'SVSyncBalancer: balancing by {Name.to_str(name)}') _, _, _, pkt = await self.app.express_interest( name, need_raw_packet=True, must_be_fresh=True, can_be_prefix=True, lifetime=self.PROP_INTEREST_LIFETIME) int_name, meta_info, content, sig_ptrs = parse_data(pkt) isValidated = await self.secOptions.validate(int_name, sig_ptrs) return StateVector(bytes( content)) if bytes(content) != b'' and isValidated else None except (InterestNack, InterestTimeout, InterestCanceled, ValidationFailure): SVSyncLogger.info( f'SVSyncBalancer: failed to balance from {Name.to_str(name)}') return None
async def send_repo_command(self, node_prefix : NonStrictName, verb : str , datainfo : DatainfoTlvModel): # "/a/b" -> list of bytearrays name = Name.normalize(node_prefix) # "/a/b" -> "/a/b/insert" name.append(Component.from_str(verb)) datainfo_name_component = Component.from_bytes(datainfo.encode()) name.append(datainfo_name_component) logging.info('Interest Sent: {}'.format(Name.to_str(name))) try: data_name, meta_info, content = await self.app.express_interest(name, must_be_fresh=True, can_be_prefix=False, nonce=gen_nonce(), lifetime=1000) logging.info('Data Received: {}\n'.format(Name.to_str(data_name))) # print(meta_info) # print(bytes(content) if content else None) except InterestNack as e: # A NACK is received logging.warning(f'Interest Nacked with reason={e.reason}\n') return 0 except InterestTimeout: # Interest times out logging.warning(f'Interest Timeout\n') return 0 # results = self.parse_results(content) # logging.info(results) return 1
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 getDataName(self, nid: Name, seqno: int) -> Name: return (self.groupPrefix + [Component.from_str("data")] + nid + [Component.from_str(str(seqno))])
def test_mixed_name(): name = ['local', Component.from_str('ndn'), 'prefix'] interest = make_interest(name, InterestParam()) assert interest == b'\x05\x1a\x07\x14\x08\x05local\x08\x03ndn\x08\x06prefix\x0c\x02\x0f\xa0'
def test_signing_suggest(): with TemporaryDirectory() as tmpdirname: pib_file = os.path.join(tmpdirname, 'pib.db') tpm_dir = os.path.join(tmpdirname, 'privKeys') KeychainSqlite3.initialize(pib_file, 'tpm-file', tpm_dir) keychain = KeychainSqlite3(pib_file, TpmFile(tpm_dir)) assert len(keychain) == 0 la_id = keychain.touch_identity('/la') la_cert = la_id.default_key().default_cert().data la_cert_data = parse_certificate(la_cert) la_cert_name = la_cert_data.name la_signer = keychain.get_signer({'cert': la_cert_name}) la_author_id = keychain.touch_identity('/la/author/1') la_author_cert_name, la_author_cert = derive_cert(la_author_id.default_key().name, Component.from_str('la-signer'), la_cert_data.content, la_signer, datetime.utcnow(), 100) keychain.import_cert(la_id.default_key().name, la_author_cert_name, la_author_cert) ny_id = keychain.touch_identity('/ny') ny_cert = ny_id.default_key().default_cert().data ny_cert_data = parse_certificate(ny_cert) ny_cert_name = ny_cert_data.name ny_signer = keychain.get_signer({'cert': ny_cert_name}) ny_author_id = keychain.touch_identity('/ny/author/2') ny_author_cert_name, ny_author_cert = derive_cert(ny_author_id.default_key().name, Component.from_str('ny-signer'), ny_cert_data.content, ny_signer, datetime.utcnow(), 100) keychain.import_cert(ny_id.default_key().name, ny_author_cert_name, ny_author_cert) lvs = r''' #KEY: "KEY"/_/_/_ #article: /"article"/_topic/_ & { _topic: "eco" | "spo" } <= #author #author: /site/"author"/_/#KEY <= #anchor #anchor: /site/#KEY & {site: "la" | "ny" } ''' checker = Checker(compile_lvs(lvs), {}) assert checker.suggest("/article/eco/day1", keychain) == la_author_cert_name assert checker.suggest("/article/life/day1", keychain) is None lvs = r''' #KEY: "KEY"/_/_/_ #LAKEY: "KEY"/_/_signer/_ & { _signer: "la-signer" } #article: /"article"/_topic/_ & { _topic: "eco" | "spo" } <= #author #author: /site/"author"/_/#LAKEY <= #anchor #anchor: /site/#KEY & {site: "la"} ''' checker = Checker(compile_lvs(lvs), {}) assert checker.suggest("/article/eco/day1", keychain) == la_author_cert_name lvs = r''' #KEY: "KEY"/_/_/_version & { _version: $eq_type("v=0") } #article: /"article"/_topic/_ & { _topic: "life" | "fin" } <= #author #author: /site/"author"/_/#KEY & { site: "ny" } <= #anchor #anchor: /site/#KEY & { site: "ny" } ''' checker = Checker(compile_lvs(lvs), DEFAULT_USER_FNS) assert checker.suggest("/article/fin/day1", keychain) == ny_author_cert_name lvs = r''' #KEY: "KEY"/_/_/_version & { _version: $eq_type("v=0") } #NYKEY: "KEY"/_/_signer/_version& { _signer: "ny-signer", _version: $eq_type("v=0")} #article: /"article"/_topic/_ <= #author #author: /site/"author"/_/#NYKEY <= #anchor #anchor: /site/#KEY & {site: "ny"} #site: "ny" ''' checker = Checker(compile_lvs(lvs), DEFAULT_USER_FNS) assert checker.suggest("/article/eco/day1", keychain) == ny_author_cert_name
def test_invalid_type(): # 0-typed component is not checked in ndn-python assert Component.from_str("0=A") == b'\x00\x01A' with pytest.raises(struct.error): Component.from_str("-1=A") with pytest.raises(ValueError): Component.from_str("+=A") with pytest.raises(ValueError): Component.from_str("1=2=A") with pytest.raises(ValueError): Component.from_str("==A") with pytest.raises(ValueError): Component.from_str("%%") with pytest.raises(ValueError): Component.from_str("ABCD%EF%0") with pytest.raises(ValueError): Component.from_str("ABCD%GH") with pytest.raises(ValueError): Component.to_str(b'\x00\x01ABC') with pytest.raises(ValueError): Component.from_str('sha256digest=a04z')
def getDataName(self, nid: Name, seqNum: int) -> Name: return (self.groupPrefix + [Component.from_str("d")] + nid + Name.from_str("/epoch-" + str(seqNum)))