def _tester():
# note: we run everything in a separate process to re-initialize all global states from scratch
# this helps us avoid undesirable side-effects when running multiple tests in sequence
loop = asyncio.get_event_loop()
protocol = loop.run_until_complete(DHTProtocol.create(
DHTID.generate(), bucket_size=20, depth_modulo=5, wait_timeout=5, num_replicas=3, listen=False))
key, value, expiration = DHTID.generate(), [random.random(), {'ololo': 'pyshpysh'}], get_dht_time() + 1e3
empty_item, nodes_found = loop.run_until_complete(
protocol.call_find(f'{LOCALHOST}:{peer_port}', [key]))[key]
assert empty_item is None and len(nodes_found) == 0
assert all(loop.run_until_complete(protocol.call_store(
f'{LOCALHOST}:{peer_port}', [key], [hivemind.MSGPackSerializer.dumps(value)], expiration)
)), "peer rejected store"
(recv_value_bytes, recv_expiration), nodes_found = loop.run_until_complete(
protocol.call_find(f'{LOCALHOST}:{peer_port}', [key]))[key]
recv_value = hivemind.MSGPackSerializer.loads(recv_value_bytes)
assert len(nodes_found) == 0
assert recv_value == value and recv_expiration == expiration, "call_find_value expected " \
f"{value} (expires by {expiration}) but got {recv_value} (expires by {recv_expiration})"
assert loop.run_until_complete(protocol.call_ping(f'{LOCALHOST}:{peer_port}')) == peer_id
assert loop.run_until_complete(protocol.call_ping(f'{LOCALHOST}:{hivemind.find_open_port()}')) is None
test_success.set()
def run_protocol_listener(port: int, dhtid: DHTID, started: mp.synchronize.Event, ping: Optional[Endpoint] = None):
loop = asyncio.get_event_loop()
protocol = loop.run_until_complete(DHTProtocol.create(
dhtid, bucket_size=20, depth_modulo=5, num_replicas=3, wait_timeout=5, listen_on=f"{LOCALHOST}:{port}"))
assert protocol.port == port
print(f"Started peer id={protocol.node_id} port={port}", flush=True)
if ping is not None:
loop.run_until_complete(protocol.call_ping(ping))
started.set()
loop.run_until_complete(protocol.server.wait_for_termination())
print(f"Finished peer id={protocol.node_id} port={port}", flush=True)
def _tester():
# note: we run everything in a separate process to re-initialize all global states from scratch
# this helps us avoid undesirable side-effects when running multiple tests in sequence
loop = asyncio.get_event_loop()
for listen in [
False, True
]: # note: order matters, this test assumes that first run uses listen=False
protocol = loop.run_until_complete(
DHTProtocol.create(DHTID.generate(),
bucket_size=20,
depth_modulo=5,
wait_timeout=5,
num_replicas=3,
listen=listen))
print(f"Self id={protocol.node_id}", flush=True)
assert loop.run_until_complete(
protocol.call_ping(f'{LOCALHOST}:{peer1_port}')) == peer1_id
key, value, expiration = DHTID.generate(), [
random.random(), {
'ololo': 'pyshpysh'
}
], get_dht_time() + 1e3
store_ok = loop.run_until_complete(
protocol.call_store(f'{LOCALHOST}:{peer1_port}', [key],
[hivemind.MSGPackSerializer.dumps(value)],
expiration))
assert all(store_ok), "DHT rejected a trivial store"
# peer 1 must know about peer 2
recv_value_bytes, recv_expiration, nodes_found = loop.run_until_complete(
protocol.call_find(f'{LOCALHOST}:{peer1_port}', [key]))[key]
recv_value = hivemind.MSGPackSerializer.loads(recv_value_bytes)
(recv_id, recv_endpoint) = next(iter(nodes_found.items()))
assert recv_id == peer2_id and ':'.join(recv_endpoint.split(':')[-2:]) == f"{LOCALHOST}:{peer2_port}", \
f"expected id={peer2_id}, peer={LOCALHOST}:{peer2_port} but got {recv_id}, {recv_endpoint}"
assert recv_value == value and recv_expiration == expiration, \
f"call_find_value expected {value} (expires by {expiration}) " \
f"but got {recv_value} (expires by {recv_expiration})"
# peer 2 must know about peer 1, but not have a *random* nonexistent value
dummy_key = DHTID.generate()
recv_dummy_value, recv_dummy_expiration, nodes_found_2 = loop.run_until_complete(
protocol.call_find(f'{LOCALHOST}:{peer2_port}',
[dummy_key]))[dummy_key]
assert recv_dummy_value is None and recv_dummy_expiration is None, "Non-existent keys shouldn't have values"
(recv_id, recv_endpoint) = next(iter(nodes_found_2.items()))
assert recv_id == peer1_id and recv_endpoint == f"{LOCALHOST}:{peer1_port}", \
f"expected id={peer1_id}, peer={LOCALHOST}:{peer1_port} but got {recv_id}, {recv_endpoint}"
# cause a non-response by querying a nonexistent peer
dummy_port = hivemind.find_open_port()
assert loop.run_until_complete(
protocol.call_find(f"{LOCALHOST}:{dummy_port}", [key])) is None
if listen:
loop.run_until_complete(protocol.shutdown())
print("DHTProtocol test finished successfully!")
test_success.set()