| import re |
|
|
| from multiaddr import ( |
| Multiaddr, |
| ) |
| from p2pclient.utils import ( |
| get_unused_tcp_port, |
| ) |
| import pytest |
| import trio |
|
|
| from libp2p.peer.peerinfo import ( |
| PeerInfo, |
| info_from_p2p_addr, |
| ) |
| from libp2p.tools.factories import ( |
| HostFactory, |
| ) |
| from libp2p.tools.interop.envs import ( |
| GO_BIN_PATH, |
| ) |
| from libp2p.tools.interop.process import ( |
| BaseInteractiveProcess, |
| ) |
| from libp2p.typing import ( |
| TProtocol, |
| ) |
|
|
| ECHO_PATH = GO_BIN_PATH / "echo" |
| ECHO_PROTOCOL_ID = TProtocol("/echo/1.0.0") |
|
|
|
|
| class EchoProcess(BaseInteractiveProcess): |
| port: int |
| _peer_info: PeerInfo |
|
|
| def __init__( |
| self, port: int, security_protocol: TProtocol, destination: Multiaddr = None |
| ) -> None: |
| args = [f"-l={port}", f"-security={security_protocol}"] |
| if destination is not None: |
| args.append(f"-d={str(destination)}") |
|
|
| patterns = [b"I am"] |
| if destination is None: |
| patterns.append(b"listening for connections") |
|
|
| self.args = args |
| self.cmd = str(ECHO_PATH) |
| self.patterns = patterns |
| self.bytes_read = bytearray() |
| self.event_ready = trio.Event() |
|
|
| self.port = port |
| self._peer_info = None |
| self.regex_pat = re.compile(rb"I am ([\w\./]+)") |
|
|
| @property |
| def peer_info(self) -> None: |
| if self._peer_info is not None: |
| return self._peer_info |
| if not self.event_ready.is_set(): |
| raise Exception("process is not ready yet. failed to parse the peer info") |
| |
| |
| m = re.search(rb"I am ([\w\./]+)", self.bytes_read) |
| if m is None: |
| raise Exception("failed to find the pattern for the listening multiaddr") |
| maddr_bytes_str_ipfs = m.group(1) |
| maddr_str = maddr_bytes_str_ipfs.decode().replace("ipfs", "p2p") |
| maddr = Multiaddr(maddr_str) |
| self._peer_info = info_from_p2p_addr(maddr) |
| return self._peer_info |
|
|
|
|
| @pytest.mark.trio |
| async def test_insecure_conn_py_to_go(security_protocol): |
| async with HostFactory.create_batch_and_listen( |
| 1, security_protocol=security_protocol |
| ) as hosts: |
| go_proc = EchoProcess(get_unused_tcp_port(), security_protocol) |
| await go_proc.start() |
|
|
| host = hosts[0] |
| peer_info = go_proc.peer_info |
| await host.connect(peer_info) |
| s = await host.new_stream(peer_info.peer_id, [ECHO_PROTOCOL_ID]) |
| data = "data321123\n" |
| await s.write(data.encode()) |
| echoed_resp = await s.read(len(data)) |
| assert echoed_resp.decode() == data |
| await s.close() |
|
|
|
|
| @pytest.mark.trio |
| async def test_insecure_conn_go_to_py(security_protocol): |
| async with HostFactory.create_batch_and_listen( |
| 1, security_protocol=security_protocol |
| ) as hosts: |
| host = hosts[0] |
| expected_data = "Hello, world!\n" |
| reply_data = "Replyooo!\n" |
| event_handler_finished = trio.Event() |
|
|
| async def _handle_echo(stream): |
| read_data = await stream.read(len(expected_data)) |
| assert read_data == expected_data.encode() |
| await stream.write(reply_data.encode()) |
| await stream.close() |
| event_handler_finished.set() |
|
|
| host.set_stream_handler(ECHO_PROTOCOL_ID, _handle_echo) |
| py_maddr = host.get_addrs()[0] |
| go_proc = EchoProcess(get_unused_tcp_port(), security_protocol, py_maddr) |
| await go_proc.start() |
| await event_handler_finished.wait() |
|
|
