async def test_packer_sends_packets(
nursery,
packer,
remote_enr,
remote_endpoint,
outbound_message_channels,
outbound_packet_channels,
):
assert not packer.is_peer_packer_registered(remote_enr.node_id)
# send message
outbound_message = OutboundMessage(
message=PingMessageFactory(),
receiver_endpoint=remote_endpoint,
receiver_node_id=remote_enr.node_id,
)
outbound_message_channels[0].send_nowait(outbound_message)
with trio.fail_after(0.5):
outbound_packet = await outbound_packet_channels[1].receive()
assert packer.is_peer_packer_registered(remote_enr.node_id)
assert isinstance(outbound_packet.packet, AuthTagPacket)
assert outbound_packet.receiver_endpoint == remote_endpoint
async def test_ping_handler_requests_updated_enr(
ping_handler_service,
inbound_message_channels,
outbound_message_channels,
local_enr,
remote_enr,
routing_table,
):
ping = PingMessageFactory(enr_seq=remote_enr.sequence_number + 1)
inbound_message = InboundMessageFactory(message=ping)
await inbound_message_channels[0].send(inbound_message)
await wait_all_tasks_blocked()
first_outbound_message = outbound_message_channels[1].receive_nowait()
await wait_all_tasks_blocked()
second_outbound_message = outbound_message_channels[1].receive_nowait()
assert {
first_outbound_message.message.__class__,
second_outbound_message.message.__class__,
} == {PongMessage, FindNodeMessage}
outbound_find_node = (first_outbound_message if isinstance(
first_outbound_message.message, FindNodeMessage) else
second_outbound_message)
assert outbound_find_node.message.distance == 0
assert outbound_find_node.receiver_endpoint == inbound_message.sender_endpoint
assert outbound_find_node.receiver_node_id == inbound_message.sender_node_id
async def test_ping_handler_updates_routing_table(
ping_handler_service,
inbound_message_channels,
outbound_message_channels,
local_enr,
remote_enr,
routing_table,
):
distance = compute_log_distance(remote_enr.node_id, local_enr.node_id)
other_node_id = NodeIDFactory.at_log_distance(local_enr.node_id, distance)
routing_table.update(other_node_id)
assert routing_table.get_nodes_at_log_distance(distance) == (
other_node_id,
remote_enr.node_id,
)
ping = PingMessageFactory()
inbound_message = InboundMessageFactory(
message=ping,
sender_node_id=remote_enr.node_id,
)
await inbound_message_channels[0].send(inbound_message)
await wait_all_tasks_blocked()
assert routing_table.get_nodes_at_log_distance(distance) == (
remote_enr.node_id,
other_node_id,
)
async def test_full_peer_packer_handshake(
peer_packer,
remote_peer_packer,
endpoint,
remote_endpoint,
enr,
remote_enr,
outbound_message_channels,
remote_outbound_message_channels,
inbound_message_channels,
remote_inbound_message_channels,
bridged_channels,
nursery,
):
# to remote
outbound_message = OutboundMessage(
message=PingMessageFactory(),
receiver_endpoint=remote_endpoint,
receiver_node_id=remote_enr.node_id,
)
outbound_message_channels[0].send_nowait(outbound_message)
with trio.fail_after(0.5):
inbound_message = await remote_inbound_message_channels[1].receive()
assert inbound_message.message == outbound_message.message
assert inbound_message.sender_endpoint == endpoint
assert inbound_message.sender_node_id == enr.node_id
# from remote
outbound_message = OutboundMessage(
message=PingMessageFactory(),
receiver_endpoint=endpoint,
receiver_node_id=enr.node_id,
)
remote_outbound_message_channels[0].send_nowait(outbound_message)
with trio.fail_after(0.5):
inbound_message = await inbound_message_channels[1].receive()
assert inbound_message.message == outbound_message.message
assert inbound_message.sender_endpoint == remote_endpoint
assert inbound_message.sender_node_id == remote_enr.node_id
async def test_request(
message_dispatcher,
remote_enr,
remote_endpoint,
inbound_message_channels,
outbound_message_channels,
nursery,
):
request_id = message_dispatcher.get_free_request_id(remote_enr.node_id)
request = PingMessageFactory(request_id=request_id)
response = PingMessageFactory(request_id=request_id)
async def handle_request_on_remote():
async for outbound_message in outbound_message_channels[1]:
assert outbound_message.message == request
assert outbound_message.receiver_endpoint == remote_endpoint
assert outbound_message.receiver_node_id == remote_enr.node_id
await inbound_message_channels[0].send(
InboundMessage(
message=response,
sender_endpoint=remote_endpoint,
sender_node_id=remote_enr.node_id,
))
nursery.start_soon(handle_request_on_remote)
received_response = await message_dispatcher.request(
remote_enr.node_id, request)
assert received_response.message == response
assert received_response.sender_endpoint == remote_endpoint
assert received_response.sender_node_id == remote_enr.node_id
received_response_with_explicit_endpoint = await message_dispatcher.request(
remote_enr.node_id,
request,
endpoint=remote_endpoint,
)
assert received_response_with_explicit_endpoint == received_response
async def test_peer_packer_sends_auth_header(
peer_packer,
enr,
remote_private_key,
remote_enr,
remote_endpoint,
inbound_packet_channels,
outbound_packet_channels,
outbound_message_channels,
nursery,
):
outbound_message = OutboundMessage(
PingMessageFactory(),
remote_endpoint,
peer_packer.remote_node_id,
)
outbound_message_channels[0].send_nowait(outbound_message)
with trio.fail_after(0.5):
outbound_auth_tag_packet = await outbound_packet_channels[1].receive()
handshake_recipient = HandshakeRecipientFactory(
local_private_key=remote_private_key,
local_enr=remote_enr,
remote_private_key=peer_packer.local_private_key,
remote_enr=enr,
remote_node_id=peer_packer.local_node_id,
initiating_packet_auth_tag=outbound_auth_tag_packet.packet.auth_tag,
)
inbound_packet = InboundPacket(
handshake_recipient.first_packet_to_send,
sender_endpoint=remote_endpoint,
)
inbound_packet_channels[0].send_nowait(inbound_packet)
with trio.fail_after(0.5):
outbound_auth_header_packet = await outbound_packet_channels[
1].receive()
assert peer_packer.is_post_handshake
assert isinstance(outbound_auth_header_packet.packet, AuthHeaderPacket)
assert outbound_auth_header_packet.receiver_endpoint == remote_endpoint
handshake_result = handshake_recipient.complete_handshake(
outbound_auth_header_packet.packet, )
initiator_keys = peer_packer.session_keys
recipient_keys = handshake_result.session_keys
assert initiator_keys.auth_response_key == recipient_keys.auth_response_key
assert initiator_keys.encryption_key == recipient_keys.decryption_key
assert initiator_keys.decryption_key == recipient_keys.encryption_key
async def test_peer_packer_initiates_handshake(peer_packer,
outbound_message_channels,
outbound_packet_channels,
nursery):
outbound_message = OutboundMessage(
PingMessageFactory(),
EndpointFactory(),
peer_packer.remote_node_id,
)
outbound_message_channels[0].send_nowait(outbound_message)
with trio.fail_after(0.5):
outbound_packet = await outbound_packet_channels[1].receive()
assert peer_packer.is_during_handshake
assert outbound_packet.receiver_endpoint == outbound_message.receiver_endpoint
assert isinstance(outbound_packet.packet, AuthTagPacket)
async def test_ping_handler_sends_pong(
ping_handler_service,
inbound_message_channels,
outbound_message_channels,
local_enr,
):
ping = PingMessageFactory()
inbound_message = InboundMessageFactory(message=ping)
await inbound_message_channels[0].send(inbound_message)
await wait_all_tasks_blocked()
outbound_message = outbound_message_channels[1].receive_nowait()
assert isinstance(outbound_message.message, PongMessage)
assert outbound_message.message.request_id == ping.request_id
assert outbound_message.message.enr_seq == local_enr.sequence_number
assert outbound_message.receiver_endpoint == inbound_message.sender_endpoint
assert outbound_message.receiver_node_id == inbound_message.sender_node_id
async def test_request_handling(message_dispatcher, inbound_message_channels,
remote_enr, remote_endpoint):
ping_send_channel, ping_receive_channel = trio.open_memory_channel(0)
async with message_dispatcher.add_request_handler(
PingMessage) as request_subscription:
inbound_message = InboundMessage(
message=PingMessageFactory(),
sender_endpoint=remote_endpoint,
sender_node_id=remote_enr.node_id,
)
await inbound_message_channels[0].send(inbound_message)
with trio.fail_after(1):
handled_inbound_message = await request_subscription.receive()
assert handled_inbound_message == inbound_message
async def test_response_handling(message_dispatcher, remote_enr,
inbound_message_channels):
request_id = message_dispatcher.get_free_request_id(remote_enr.node_id)
async with message_dispatcher.add_response_handler(
remote_enr.node_id,
request_id,
) as response_subscription:
inbound_message = InboundMessage(
message=PingMessageFactory(request_id=request_id, ),
sender_endpoint=remote_endpoint,
sender_node_id=remote_enr.node_id,
)
await inbound_message_channels[0].send(inbound_message)
with trio.fail_after(1):
handled_response = await response_subscription.receive()
assert handled_response == inbound_message