async def test_last_msg_time(monkeypatch):
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
assert alice_multiplexer.last_msg_time == 0
assert bob_multiplexer.last_msg_time == 0
alice_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
now = time.monotonic()
monkeypatch.setattr(time, 'monotonic', lambda: now)
alice_p2p_protocol.send(Ping(None))
cmd = await asyncio.wait_for(bob_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
assert bob_multiplexer.last_msg_time == now
bob_p2p_protocol.send(Pong(None))
cmd = await asyncio.wait_for(alice_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Pong)
assert alice_multiplexer.last_msg_time == now
async def test_stream_protocol_messages(request, event_loop, monkeypatch):
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
await run_multiplexers([alice_multiplexer, bob_multiplexer], request,
event_loop)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(P2PProtocolV5)
alice_p2p_protocol.send(Ping(None))
alice_p2p_protocol.send(Pong(None))
monkeypatch.setattr(bob_multiplexer, '_stream_idle_timeout', 0.1)
stream = bob_multiplexer.stream_protocol_messages(P2PProtocolV5)
cmd = await asyncio.wait_for(stream.asend(None), timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
cmd = await asyncio.wait_for(stream.asend(None), timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Pong)
# Stopping streaming on bob's multiplexer should cause stream_protocol_messages() to
# terminate.
stop_streaming_task = asyncio.create_task(bob_multiplexer.stop_streaming())
try:
cmd = await asyncio.wait_for(stream.asend(None),
timeout=DEFAULT_TIMEOUT)
except StopAsyncIteration:
pass
assert stop_streaming_task.done()
async def handle(self, connection: ConnectionAPI, cmd: Ping) -> None:
connection.logger.debug2("Received ping on %s, replying with pong",
connection)
try:
connection.get_base_protocol().send(Pong(None))
except PeerConnectionLost:
connection.logger.debug2("%s disconnected while sending pong",
connection)
async def test_multiplexer_p2p_and_paragon_protocol():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory(
protocol_types=(SecondProtocol, ), )
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_p2p_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_p2p_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_second_stream = alice_multiplexer.stream_protocol_messages(
SecondProtocol)
bob_second_stream = bob_multiplexer.stream_protocol_messages(
SecondProtocol)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
alice_second_protocol = alice_multiplexer.get_protocol_by_type(
SecondProtocol)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_second_protocol = bob_multiplexer.get_protocol_by_type(
SecondProtocol)
alice_second_protocol.send(CommandA(None))
alice_p2p_protocol.send(Ping(None))
alice_second_protocol.send(CommandB(None))
cmd = await asyncio.wait_for(bob_p2p_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
bob_second_protocol.send(CommandA(None))
bob_p2p_protocol.send(Pong(None))
bob_second_protocol.send(CommandB(None))
cmd = await asyncio.wait_for(alice_p2p_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Pong)
cmd_1 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_2 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_3 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
cmd_4 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=DEFAULT_TIMEOUT
) # noqa: E501
assert isinstance(cmd_1, CommandA)
assert isinstance(cmd_2, CommandB)
assert isinstance(cmd_3, CommandA)
assert isinstance(cmd_4, CommandB)
async def test_multiplexer_only_p2p_protocol(request, event_loop):
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
await run_multiplexers([alice_multiplexer, bob_multiplexer], request,
event_loop)
alice_stream = alice_multiplexer.stream_protocol_messages(P2PProtocolV5)
bob_stream = bob_multiplexer.stream_protocol_messages(P2PProtocolV5)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(P2PProtocolV5)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(P2PProtocolV5)
alice_p2p_protocol.send(Ping(None))
cmd = await asyncio.wait_for(bob_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
assert isinstance(cmd, Ping)
bob_p2p_protocol.send(Pong(None))
cmd = await asyncio.wait_for(alice_stream.asend(None),
timeout=DEFAULT_TIMEOUT)
async def test_multiplexer_only_p2p_protocol():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory()
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
alice_p2p_protocol.send(Ping(None))
cmd = await asyncio.wait_for(bob_stream.asend(None), timeout=0.1)
assert isinstance(cmd, Ping)
bob_p2p_protocol.send(Pong(None))
cmd = await asyncio.wait_for(alice_stream.asend(None), timeout=0.1)
def send_pong(self) -> None:
self.connection.get_base_protocol().send(Pong(None))
async def handle(self, connection: ConnectionAPI, cmd: Ping) -> None:
connection.logger.debug2("Received ping on %s, replying with pong",
connection)
connection.get_base_protocol().send(Pong(None))
async def test_multiplexer_p2p_and_two_more_protocols():
alice_multiplexer, bob_multiplexer = MultiplexerPairFactory(
protocol_types=(SecondProtocol, ThirdProtocol), )
async with alice_multiplexer.multiplex():
async with bob_multiplexer.multiplex():
alice_p2p_stream = alice_multiplexer.stream_protocol_messages(
P2PProtocolV5)
bob_p2p_stream = bob_multiplexer.stream_protocol_messages(
P2PProtocolV5)
alice_second_stream = alice_multiplexer.stream_protocol_messages(
SecondProtocol)
bob_second_stream = bob_multiplexer.stream_protocol_messages(
SecondProtocol)
alice_third_stream = alice_multiplexer.stream_protocol_messages(
ThirdProtocol)
bob_third_stream = bob_multiplexer.stream_protocol_messages(
ThirdProtocol)
alice_p2p_protocol = alice_multiplexer.get_protocol_by_type(
P2PProtocolV5)
alice_second_protocol = alice_multiplexer.get_protocol_by_type(
SecondProtocol)
alice_third_protocol = alice_multiplexer.get_protocol_by_type(
ThirdProtocol)
bob_p2p_protocol = bob_multiplexer.get_protocol_by_type(
P2PProtocolV5)
bob_second_protocol = bob_multiplexer.get_protocol_by_type(
SecondProtocol)
bob_third_protocol = bob_multiplexer.get_protocol_by_type(
ThirdProtocol)
alice_second_protocol.send(CommandA(None))
alice_third_protocol.send(CommandC(None))
alice_p2p_protocol.send(Ping(None))
alice_second_protocol.send(CommandB(None))
alice_third_protocol.send(CommandD(None))
cmd = await asyncio.wait_for(bob_p2p_stream.asend(None),
timeout=0.1)
assert isinstance(cmd, Ping)
bob_second_protocol.send(CommandA(None))
bob_third_protocol.send(CommandC(None))
bob_p2p_protocol.send(Pong(None))
bob_second_protocol.send(CommandB(None))
bob_third_protocol.send(CommandD(None))
cmd = await asyncio.wait_for(alice_p2p_stream.asend(None),
timeout=0.1)
assert isinstance(cmd, Pong)
cmd_1 = await asyncio.wait_for(bob_third_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_2 = await asyncio.wait_for(bob_third_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_3 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_4 = await asyncio.wait_for(bob_second_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_5 = await asyncio.wait_for(alice_third_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_6 = await asyncio.wait_for(alice_third_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_7 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=0.1) # noqa: E501
cmd_8 = await asyncio.wait_for(alice_second_stream.asend(None),
timeout=0.1) # noqa: E501
assert isinstance(cmd_1, CommandC)
assert isinstance(cmd_2, CommandD)
assert isinstance(cmd_3, CommandA)
assert isinstance(cmd_4, CommandB)
assert isinstance(cmd_5, CommandC)
assert isinstance(cmd_6, CommandD)
assert isinstance(cmd_7, CommandA)
assert isinstance(cmd_8, CommandB)
async def _handle_ping(connection: ConnectionAPI, msg: Any) -> None:
got_ping.set()
bob_connection.get_base_protocol().send(Pong(None))
async def handle(self, connection: ConnectionAPI, cmd: Ping) -> None:
connection.get_base_protocol().send(Pong(None))