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)))
