94 lines
3.1 KiB
Python
94 lines
3.1 KiB
Python
import asyncio
|
|
import os
|
|
import pathlib
|
|
import sys
|
|
|
|
from multiaddr import Multiaddr
|
|
import pexpect
|
|
import pytest
|
|
|
|
from libp2p import generate_new_rsa_identity, new_node
|
|
from libp2p.peer.peerinfo import info_from_p2p_addr
|
|
from libp2p.security.insecure.transport import PLAINTEXT_PROTOCOL_ID, InsecureTransport
|
|
from libp2p.typing import TProtocol
|
|
from tests.configs import LISTEN_MADDR
|
|
|
|
|
|
GOPATH = pathlib.Path(os.environ["GOPATH"])
|
|
ECHO_PATH = GOPATH / "bin" / "echo"
|
|
ECHO_PROTOCOL_ID = TProtocol("/echo/1.0.0")
|
|
NEW_LINE = "\r\n"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_insecure_conn_py_to_go(unused_tcp_port):
|
|
try:
|
|
go_proc = pexpect.spawn(
|
|
str(ECHO_PATH),
|
|
[f"-l={unused_tcp_port}", "-insecure"],
|
|
logfile=sys.stdout,
|
|
encoding="utf-8",
|
|
)
|
|
await go_proc.expect(r"I am ([\w\./]+)" + NEW_LINE, async_=True)
|
|
maddr_str = go_proc.match.group(1)
|
|
maddr_str = maddr_str.replace("ipfs", "p2p")
|
|
maddr = Multiaddr(maddr_str)
|
|
go_pinfo = info_from_p2p_addr(maddr)
|
|
await go_proc.expect("listening for connections", async_=True)
|
|
|
|
key_pair = generate_new_rsa_identity()
|
|
insecure_tpt = InsecureTransport(key_pair)
|
|
host = await new_node(
|
|
key_pair=key_pair, sec_opt={PLAINTEXT_PROTOCOL_ID: insecure_tpt}
|
|
)
|
|
await host.connect(go_pinfo)
|
|
await go_proc.expect("swarm listener accepted connection", async_=True)
|
|
s = await host.new_stream(go_pinfo.peer_id, [ECHO_PROTOCOL_ID])
|
|
|
|
await go_proc.expect("Got a new stream!", async_=True)
|
|
data = "data321123\n"
|
|
await s.write(data.encode())
|
|
await go_proc.expect(f"read: {data[:-1]}", async_=True)
|
|
echoed_resp = await s.read(len(data))
|
|
assert echoed_resp.decode() == data
|
|
await s.close()
|
|
finally:
|
|
go_proc.close()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_insecure_conn_go_to_py(unused_tcp_port):
|
|
key_pair = generate_new_rsa_identity()
|
|
insecure_tpt = InsecureTransport(key_pair)
|
|
host = await new_node(
|
|
key_pair=key_pair, sec_opt={PLAINTEXT_PROTOCOL_ID: insecure_tpt}
|
|
)
|
|
await host.get_network().listen(LISTEN_MADDR)
|
|
expected_data = "Hello, world!\n"
|
|
reply_data = "Replyooo!\n"
|
|
event_handler_finished = asyncio.Event()
|
|
|
|
async def _handle_echo(stream):
|
|
read_data = await stream.read(len(expected_data))
|
|
assert read_data == expected_data.encode()
|
|
event_handler_finished.set()
|
|
await stream.write(reply_data.encode())
|
|
await stream.close()
|
|
|
|
host.set_stream_handler(ECHO_PROTOCOL_ID, _handle_echo)
|
|
py_maddr = host.get_addrs()[0]
|
|
go_proc = pexpect.spawn(
|
|
str(ECHO_PATH),
|
|
[f"-l={unused_tcp_port}", "-insecure", f"-d={str(py_maddr)}"],
|
|
logfile=sys.stdout,
|
|
encoding="utf-8",
|
|
)
|
|
try:
|
|
await go_proc.expect(r"I am ([\w\./]+)" + NEW_LINE, async_=True)
|
|
await go_proc.expect("connect with peer", async_=True)
|
|
await go_proc.expect("opened stream", async_=True)
|
|
await event_handler_finished.wait()
|
|
await go_proc.expect(f"read reply: .*{reply_data.rstrip()}.*", async_=True)
|
|
finally:
|
|
go_proc.close()
|