import asyncio import sys from typing import Union from p2pclient.datastructures import StreamInfo import pexpect import pytest from libp2p.io.abc import ReadWriteCloser from libp2p.tools.constants import GOSSIPSUB_PARAMS, LISTEN_MADDR from libp2p.tools.factories import ( FloodsubFactory, GossipsubFactory, HostFactory, PubsubFactory, ) from libp2p.tools.interop.daemon import Daemon, make_p2pd from libp2p.tools.interop.utils import connect @pytest.fixture def is_host_secure(): return False @pytest.fixture def num_hosts(): return 3 @pytest.fixture async def hosts(num_hosts, is_host_secure): _hosts = HostFactory.create_batch(num_hosts, is_secure=is_host_secure) await asyncio.gather( *[_host.get_network().listen(LISTEN_MADDR) for _host in _hosts] ) try: yield _hosts finally: # TODO: It's possible that `close` raises exceptions currently, # due to the connection reset things. Though we don't care much about that when # cleaning up the tasks, it is probably better to handle the exceptions properly. await asyncio.gather( *[_host.close() for _host in _hosts], return_exceptions=True ) @pytest.fixture def proc_factory(): procs = [] def call_proc(cmd, args, logfile=None, encoding=None): if logfile is None: logfile = sys.stdout if encoding is None: encoding = "utf-8" proc = pexpect.spawn(cmd, args, logfile=logfile, encoding=encoding) procs.append(proc) return proc try: yield call_proc finally: for proc in procs: proc.close() @pytest.fixture def num_p2pds(): return 1 @pytest.fixture def is_gossipsub(): return True @pytest.fixture def is_pubsub_signing(): return True @pytest.fixture def is_pubsub_signing_strict(): return True @pytest.fixture async def p2pds( num_p2pds, is_host_secure, is_gossipsub, unused_tcp_port_factory, is_pubsub_signing, is_pubsub_signing_strict, ): p2pds: Union[Daemon, Exception] = await asyncio.gather( *[ make_p2pd( unused_tcp_port_factory(), unused_tcp_port_factory(), is_host_secure, is_gossipsub=is_gossipsub, is_pubsub_signing=is_pubsub_signing, is_pubsub_signing_strict=is_pubsub_signing_strict, ) for _ in range(num_p2pds) ], return_exceptions=True, ) p2pds_succeeded = tuple(p2pd for p2pd in p2pds if isinstance(p2pd, Daemon)) if len(p2pds_succeeded) != len(p2pds): # Not all succeeded. Close the succeeded ones and print the failed ones(exceptions). await asyncio.gather(*[p2pd.close() for p2pd in p2pds_succeeded]) exceptions = tuple(p2pd for p2pd in p2pds if isinstance(p2pd, Exception)) raise Exception(f"not all p2pds succeed: first exception={exceptions[0]}") try: yield p2pds finally: await asyncio.gather(*[p2pd.close() for p2pd in p2pds]) @pytest.fixture def pubsubs(num_hosts, hosts, is_gossipsub, is_pubsub_signing_strict): if is_gossipsub: routers = GossipsubFactory.create_batch(num_hosts, **GOSSIPSUB_PARAMS._asdict()) else: routers = FloodsubFactory.create_batch(num_hosts) _pubsubs = tuple( PubsubFactory(host=host, router=router, strict_signing=is_pubsub_signing_strict) for host, router in zip(hosts, routers) ) yield _pubsubs # TODO: Clean up class DaemonStream(ReadWriteCloser): stream_info: StreamInfo reader: asyncio.StreamReader writer: asyncio.StreamWriter def __init__( self, stream_info: StreamInfo, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, ) -> None: self.stream_info = stream_info self.reader = reader self.writer = writer async def close(self) -> None: self.writer.close() await self.writer.wait_closed() async def read(self, n: int = -1) -> bytes: return await self.reader.read(n) async def write(self, data: bytes) -> int: return self.writer.write(data) @pytest.fixture async def is_to_fail_daemon_stream(): return False @pytest.fixture async def py_to_daemon_stream_pair(hosts, p2pds, is_to_fail_daemon_stream): assert len(hosts) >= 1 assert len(p2pds) >= 1 host = hosts[0] p2pd = p2pds[0] protocol_id = "/protocol/id/123" stream_py = None stream_daemon = None event_stream_handled = asyncio.Event() await connect(host, p2pd) async def daemon_stream_handler(stream_info, reader, writer): nonlocal stream_daemon stream_daemon = DaemonStream(stream_info, reader, writer) event_stream_handled.set() await p2pd.control.stream_handler(protocol_id, daemon_stream_handler) # Sleep for a while to wait for the handler being registered. await asyncio.sleep(0.01) if is_to_fail_daemon_stream: # FIXME: This is a workaround to make daemon reset the stream. # We intentionally close the listener on the python side, it makes the connection from # daemon to us fail, and therefore the daemon resets the opened stream on their side. # Reference: https://github.com/libp2p/go-libp2p-daemon/blob/b95e77dbfcd186ccf817f51e95f73f9fd5982600/stream.go#L47-L50 # noqa: E501 # We need it because we want to test against `stream_py` after the remote side(daemon) # is reset. This should be removed after the API `stream.reset` is exposed in daemon # some day. listener = p2pds[0].control.control.listener listener.close() await listener.wait_closed() stream_py = await host.new_stream(p2pd.peer_id, [protocol_id]) if not is_to_fail_daemon_stream: await event_stream_handled.wait() # NOTE: If `is_to_fail_daemon_stream == True`, then `stream_daemon == None`. yield stream_py, stream_daemon