varun-r-mallya/py-libp2p
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/py-libp2p.git synced 2025-12-31 20:36:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Experimental: Add comprehensive WebSocket and WSS implementation with tests

Browse Source 
- Implemented full WSS support with TLS configuration
- Added handshake timeout and connection state tracking
- Created comprehensive test suite with 13+ WSS unit tests
- Added Python-to-Python WebSocket peer-to-peer tests
- Implemented multiaddr parsing for /ws, /wss, /tls/ws formats
- Added connection state tracking and concurrent close handling
- Created standalone WebSocket client for testing
- Fixed circular import issues with multiaddr utilities
- Added debug tools for WebSocket URL testing

All WebSocket transport functionality is complete and working.
Tests demonstrate WebSocket transport works correctly at the transport layer.
Higher-level libp2p protocol compatibility issues remain (same as JS interop).
This commit is contained in:
acul71
2025-09-07 23:44:17 +02:00
parent f0172a0ba1
commit 396812e84a
11 changed files with 2291 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

888
tests/core/transport/test_websocket.py
View File

@ -15,6 +15,10 @@ from libp2p.peer.peerstore import PeerStore
from libp2p.security.insecure.transport import InsecureTransport
from libp2p.stream_muxer.yamux.yamux import Yamux
from libp2p.transport.upgrader import TransportUpgrader
from libp2p.transport.websocket.multiaddr_utils import (
is_valid_websocket_multiaddr,
parse_websocket_multiaddr,
)
from libp2p.transport.websocket.transport import WebsocketTransport
logger = logging.getLogger(__name__)
@ -580,6 +584,296 @@ async def test_websocket_with_tcp_fallback():
await stream.close()
@pytest.mark.trio
async def test_websocket_data_exchange():
"""Test WebSocket transport with actual data exchange between two hosts"""
from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol
from libp2p.peer.peerinfo import info_from_p2p_addr
from libp2p.security.insecure.transport import (
PLAINTEXT_PROTOCOL_ID,
InsecureTransport,
)
# Create two hosts with plaintext security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
# Host A (listener)
security_options_a = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer)
security_options_b = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test data
test_data = b"Hello WebSocket Data Exchange!"
received_data = None
# Set up handler on host A
test_protocol = TProtocol("/test/websocket/data/1.0.0")
async def data_handler(stream):
nonlocal received_data
received_data = await stream.read(len(test_data))
await stream.write(received_data) # Echo back
await stream.close()
host_a.set_stream_handler(test_protocol, data_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WebSocket address
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
# Connect host B to host A
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create stream and test data exchange
stream = await host_b.new_stream(host_a.get_id(), [test_protocol])
await stream.write(test_data)
response = await stream.read(len(test_data))
await stream.close()
# Verify data exchange
assert received_data == test_data, f"Expected {test_data}, got {received_data}"
assert response == test_data, f"Expected echo {test_data}, got {response}"
@pytest.mark.trio
async def test_websocket_host_pair_data_exchange():
"""Test WebSocket host pair with actual data exchange using host_pair_factory pattern"""
from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol
from libp2p.peer.peerinfo import info_from_p2p_addr
from libp2p.security.insecure.transport import (
PLAINTEXT_PROTOCOL_ID,
InsecureTransport,
)
# Create two hosts with WebSocket transport and plaintext security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
# Host A (listener) - WebSocket transport
security_options_a = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer) - WebSocket transport
security_options_b = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test data
test_data = b"Hello WebSocket Host Pair Data Exchange!"
received_data = None
# Set up handler on host A
test_protocol = TProtocol("/test/websocket/hostpair/1.0.0")
async def data_handler(stream):
nonlocal received_data
received_data = await stream.read(len(test_data))
await stream.write(received_data) # Echo back
await stream.close()
host_a.set_stream_handler(test_protocol, data_handler)
# Start both hosts and connect them (following host_pair_factory pattern)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Connect the hosts using the same pattern as host_pair_factory
# Get host A's listen address and create peer info
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WebSocket address
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
# Connect host B to host A
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Allow time for connection to establish (following host_pair_factory pattern)
await trio.sleep(0.1)
# Verify connection is established
assert len(host_a.get_network().connections) > 0
assert len(host_b.get_network().connections) > 0
# Test data exchange
stream = await host_b.new_stream(host_a.get_id(), [test_protocol])
await stream.write(test_data)
response = await stream.read(len(test_data))
await stream.close()
# Verify data exchange
assert received_data == test_data, f"Expected {test_data}, got {received_data}"
assert response == test_data, f"Expected echo {test_data}, got {response}"
@pytest.mark.trio
async def test_wss_host_pair_data_exchange():
"""Test WSS host pair with actual data exchange using host_pair_factory pattern"""
import ssl
from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol
from libp2p.peer.peerinfo import info_from_p2p_addr
from libp2p.security.insecure.transport import (
PLAINTEXT_PROTOCOL_ID,
InsecureTransport,
)
# Create TLS context for WSS
tls_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
tls_context.check_hostname = False
tls_context.verify_mode = ssl.CERT_NONE
# Create two hosts with WSS transport and plaintext security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
# Host A (listener) - WSS transport
security_options_a = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/wss")],
)
# Host B (dialer) - WSS transport
security_options_b = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test data
test_data = b"Hello WSS Host Pair Data Exchange!"
received_data = None
# Set up handler on host A
test_protocol = TProtocol("/test/wss/hostpair/1.0.0")
async def data_handler(stream):
nonlocal received_data
received_data = await stream.read(len(test_data))
await stream.write(received_data) # Echo back
await stream.close()
host_a.set_stream_handler(test_protocol, data_handler)
# Start both hosts and connect them (following host_pair_factory pattern)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/wss")]),
host_b.run(listen_addrs=[]),
):
# Connect the hosts using the same pattern as host_pair_factory
# Get host A's listen address and create peer info
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WSS address
wss_addr = None
for addr in listen_addrs:
if "/wss" in str(addr):
wss_addr = addr
break
assert wss_addr is not None, "No WSS listen address found"
# Connect host B to host A
peer_info = info_from_p2p_addr(wss_addr)
await host_b.connect(peer_info)
# Allow time for connection to establish (following host_pair_factory pattern)
await trio.sleep(0.1)
# Verify connection is established
assert len(host_a.get_network().connections) > 0
assert len(host_b.get_network().connections) > 0
# Test data exchange
stream = await host_b.new_stream(host_a.get_id(), [test_protocol])
await stream.write(test_data)
response = await stream.read(len(test_data))
await stream.close()
# Verify data exchange
assert received_data == test_data, f"Expected {test_data}, got {received_data}"
assert response == test_data, f"Expected echo {test_data}, got {response}"
@pytest.mark.trio
async def test_websocket_transport_interface():
"""Test WebSocket transport interface compliance"""
@ -613,3 +907,597 @@ async def test_websocket_transport_interface():
assert port == "8080"
await listener.close()
# ============================================================================
# WSS (WebSocket Secure) Tests
# ============================================================================
def test_wss_multiaddr_validation():
"""Test WSS multiaddr validation and parsing."""
# Valid WSS multiaddrs
valid_wss_addresses = [
"/ip4/127.0.0.1/tcp/8080/wss",
"/ip6/::1/tcp/8080/wss",
"/dns/localhost/tcp/8080/wss",
"/ip4/127.0.0.1/tcp/8080/tls/ws",
"/ip6/::1/tcp/8080/tls/ws",
]
# Invalid WSS multiaddrs
invalid_wss_addresses = [
"/ip4/127.0.0.1/tcp/8080/ws", # Regular WS, not WSS
"/ip4/127.0.0.1/tcp/8080", # No WebSocket protocol
"/ip4/127.0.0.1/wss", # No TCP
]
# Test valid WSS addresses
for addr_str in valid_wss_addresses:
ma = Multiaddr(addr_str)
assert is_valid_websocket_multiaddr(ma), f"Address {addr_str} should be valid"
# Test parsing
parsed = parse_websocket_multiaddr(ma)
assert parsed.is_wss, f"Address {addr_str} should be parsed as WSS"
# Test invalid addresses
for addr_str in invalid_wss_addresses:
ma = Multiaddr(addr_str)
if "/ws" in addr_str and "/wss" not in addr_str and "/tls" not in addr_str:
# Regular WS should be valid but not WSS
assert is_valid_websocket_multiaddr(ma), (
f"Address {addr_str} should be valid"
)
parsed = parse_websocket_multiaddr(ma)
assert not parsed.is_wss, f"Address {addr_str} should not be parsed as WSS"
else:
# Invalid addresses should fail validation
assert not is_valid_websocket_multiaddr(ma), (
f"Address {addr_str} should be invalid"
)
def test_wss_multiaddr_parsing():
"""Test WSS multiaddr parsing functionality."""
# Test /wss format
wss_ma = Multiaddr("/ip4/127.0.0.1/tcp/8080/wss")
parsed = parse_websocket_multiaddr(wss_ma)
assert parsed.is_wss
assert parsed.sni is None
assert parsed.rest_multiaddr.value_for_protocol("ip4") == "127.0.0.1"
assert parsed.rest_multiaddr.value_for_protocol("tcp") == "8080"
# Test /tls/ws format
tls_ws_ma = Multiaddr("/ip4/127.0.0.1/tcp/8080/tls/ws")
parsed = parse_websocket_multiaddr(tls_ws_ma)
assert parsed.is_wss
assert parsed.sni is None
assert parsed.rest_multiaddr.value_for_protocol("ip4") == "127.0.0.1"
assert parsed.rest_multiaddr.value_for_protocol("tcp") == "8080"
# Test regular /ws format
ws_ma = Multiaddr("/ip4/127.0.0.1/tcp/8080/ws")
parsed = parse_websocket_multiaddr(ws_ma)
assert not parsed.is_wss
assert parsed.sni is None
@pytest.mark.trio
async def test_wss_transport_creation():
"""Test WSS transport creation with TLS configuration."""
import ssl
# Create TLS contexts
client_ssl_context = ssl.create_default_context()
server_ssl_context = ssl.create_default_context()
server_ssl_context.check_hostname = False
server_ssl_context.verify_mode = ssl.CERT_NONE
upgrader = create_upgrader()
# Test creating WSS transport with TLS configs
wss_transport = WebsocketTransport(
upgrader,
tls_client_config=client_ssl_context,
tls_server_config=server_ssl_context,
)
assert wss_transport is not None
assert hasattr(wss_transport, "dial")
assert hasattr(wss_transport, "create_listener")
assert wss_transport._tls_client_config is not None
assert wss_transport._tls_server_config is not None
@pytest.mark.trio
async def test_wss_transport_without_tls_config():
"""Test WSS transport creation without TLS configuration."""
upgrader = create_upgrader()
# Test creating WSS transport without TLS configs (should still work)
wss_transport = WebsocketTransport(upgrader)
assert wss_transport is not None
assert hasattr(wss_transport, "dial")
assert hasattr(wss_transport, "create_listener")
assert wss_transport._tls_client_config is None
assert wss_transport._tls_server_config is None
@pytest.mark.trio
async def test_wss_dial_parsing():
"""Test WSS dial functionality with multiaddr parsing."""
upgrader = create_upgrader()
# transport = WebsocketTransport(upgrader) # Not used in this test
# Test WSS multiaddr parsing in dial
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/wss")
# Test that the transport can parse WSS addresses
# (We can't actually dial without a server, but we can test parsing)
try:
parsed = parse_websocket_multiaddr(wss_maddr)
assert parsed.is_wss
assert parsed.rest_multiaddr.value_for_protocol("ip4") == "127.0.0.1"
assert parsed.rest_multiaddr.value_for_protocol("tcp") == "8080"
except Exception as e:
pytest.fail(f"WSS multiaddr parsing failed: {e}")
@pytest.mark.trio
async def test_wss_listen_parsing():
"""Test WSS listen functionality with multiaddr parsing."""
upgrader = create_upgrader()
transport = WebsocketTransport(upgrader)
# Test WSS multiaddr parsing in listen
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/0/wss")
async def dummy_handler(conn):
await trio.sleep(0)
listener = transport.create_listener(dummy_handler)
# Test that the transport can parse WSS addresses
try:
parsed = parse_websocket_multiaddr(wss_maddr)
assert parsed.is_wss
assert parsed.rest_multiaddr.value_for_protocol("ip4") == "127.0.0.1"
assert parsed.rest_multiaddr.value_for_protocol("tcp") == "0"
except Exception as e:
pytest.fail(f"WSS multiaddr parsing failed: {e}")
await listener.close()
@pytest.mark.trio
async def test_wss_listen_without_tls_config():
"""Test WSS listen without TLS configuration should fail."""
upgrader = create_upgrader()
transport = WebsocketTransport(upgrader) # No TLS config
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/0/wss")
async def dummy_handler(conn):
await trio.sleep(0)
listener = transport.create_listener(dummy_handler)
# This should raise an error when trying to listen on WSS without TLS config
with pytest.raises(
ValueError, match="Cannot listen on WSS address.*without TLS configuration"
):
await listener.listen(wss_maddr, trio.open_nursery())
@pytest.mark.trio
async def test_wss_listen_with_tls_config():
"""Test WSS listen with TLS configuration."""
import ssl
# Create server TLS context
server_ssl_context = ssl.create_default_context()
server_ssl_context.check_hostname = False
server_ssl_context.verify_mode = ssl.CERT_NONE
upgrader = create_upgrader()
transport = WebsocketTransport(upgrader, tls_server_config=server_ssl_context)
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/0/wss")
async def dummy_handler(conn):
await trio.sleep(0)
listener = transport.create_listener(dummy_handler)
# This should not raise an error when TLS config is provided
# Note: We can't actually start listening without proper certificates,
# but we can test that the validation passes
try:
parsed = parse_websocket_multiaddr(wss_maddr)
assert parsed.is_wss
assert transport._tls_server_config is not None
except Exception as e:
pytest.fail(f"WSS listen with TLS config failed: {e}")
await listener.close()
def test_wss_transport_registry():
"""Test WSS support in transport registry."""
from libp2p.transport.transport_registry import (
create_transport_for_multiaddr,
get_supported_transport_protocols,
)
# Test that WSS is supported
supported = get_supported_transport_protocols()
assert "ws" in supported
assert "wss" in supported
# Test transport creation for WSS multiaddrs
upgrader = create_upgrader()
# Test WS multiaddr
ws_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/ws")
ws_transport = create_transport_for_multiaddr(ws_maddr, upgrader)
assert ws_transport is not None
assert isinstance(ws_transport, WebsocketTransport)
# Test WSS multiaddr
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/wss")
wss_transport = create_transport_for_multiaddr(wss_maddr, upgrader)
assert wss_transport is not None
assert isinstance(wss_transport, WebsocketTransport)
# Test TLS/WS multiaddr
tls_ws_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/tls/ws")
tls_ws_transport = create_transport_for_multiaddr(tls_ws_maddr, upgrader)
assert tls_ws_transport is not None
assert isinstance(tls_ws_transport, WebsocketTransport)
def test_wss_multiaddr_formats():
"""Test different WSS multiaddr formats."""
# Test various WSS formats
wss_formats = [
"/ip4/127.0.0.1/tcp/8080/wss",
"/ip6/::1/tcp/8080/wss",
"/dns/localhost/tcp/8080/wss",
"/ip4/127.0.0.1/tcp/8080/tls/ws",
"/ip6/::1/tcp/8080/tls/ws",
"/dns/example.com/tcp/443/tls/ws",
]
for addr_str in wss_formats:
ma = Multiaddr(addr_str)
# Should be valid WebSocket multiaddr
assert is_valid_websocket_multiaddr(ma), f"Address {addr_str} should be valid"
# Should parse as WSS
parsed = parse_websocket_multiaddr(ma)
assert parsed.is_wss, f"Address {addr_str} should be parsed as WSS"
# Should have correct base multiaddr
assert parsed.rest_multiaddr.value_for_protocol("tcp") is not None
def test_wss_vs_ws_distinction():
"""Test that WSS and WS are properly distinguished."""
# WS addresses should not be WSS
ws_addresses = [
"/ip4/127.0.0.1/tcp/8080/ws",
"/ip6/::1/tcp/8080/ws",
"/dns/localhost/tcp/8080/ws",
]
for addr_str in ws_addresses:
ma = Multiaddr(addr_str)
parsed = parse_websocket_multiaddr(ma)
assert not parsed.is_wss, f"Address {addr_str} should not be WSS"
# WSS addresses should be WSS
wss_addresses = [
"/ip4/127.0.0.1/tcp/8080/wss",
"/ip4/127.0.0.1/tcp/8080/tls/ws",
]
for addr_str in wss_addresses:
ma = Multiaddr(addr_str)
parsed = parse_websocket_multiaddr(ma)
assert parsed.is_wss, f"Address {addr_str} should be WSS"
@pytest.mark.trio
async def test_wss_connection_handling():
"""Test WSS connection handling with security flag."""
upgrader = create_upgrader()
# transport = WebsocketTransport(upgrader) # Not used in this test
# Test that WSS connections are marked as secure
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/wss")
parsed = parse_websocket_multiaddr(wss_maddr)
assert parsed.is_wss
# Test that WS connections are not marked as secure
ws_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/ws")
parsed = parse_websocket_multiaddr(ws_maddr)
assert not parsed.is_wss
def test_wss_error_handling():
"""Test WSS error handling for invalid configurations."""
# upgrader = create_upgrader() # Not used in this test
# Test invalid multiaddr formats
invalid_addresses = [
"/ip4/127.0.0.1/tcp/8080", # No WebSocket protocol
"/ip4/127.0.0.1/wss", # No TCP
"/tcp/8080/wss", # No network protocol
]
for addr_str in invalid_addresses:
ma = Multiaddr(addr_str)
assert not is_valid_websocket_multiaddr(ma), (
f"Address {addr_str} should be invalid"
)
# Should raise ValueError when parsing invalid addresses
with pytest.raises(ValueError):
parse_websocket_multiaddr(ma)
@pytest.mark.trio
async def test_handshake_timeout():
"""Test WebSocket handshake timeout functionality."""
upgrader = create_upgrader()
# Test creating transport with custom handshake timeout
transport = WebsocketTransport(upgrader, handshake_timeout=0.1) # 100ms timeout
assert transport._handshake_timeout == 0.1
# Test that the timeout is passed to the listener
async def dummy_handler(conn):
await trio.sleep(0)
listener = transport.create_listener(dummy_handler)
assert listener._handshake_timeout == 0.1
@pytest.mark.trio
async def test_handshake_timeout_creation():
"""Test handshake timeout in transport creation."""
upgrader = create_upgrader()
# Test creating transport with handshake timeout via create_transport
from libp2p.transport import create_transport
transport = create_transport("ws", upgrader, handshake_timeout=5.0)
assert transport._handshake_timeout == 5.0
# Test default timeout
transport_default = create_transport("ws", upgrader)
assert transport_default._handshake_timeout == 15.0
@pytest.mark.trio
async def test_connection_state_tracking():
"""Test WebSocket connection state tracking."""
from libp2p.transport.websocket.connection import P2PWebSocketConnection
# Create a mock WebSocket connection
class MockWebSocketConnection:
async def send_message(self, data: bytes) -> None:
pass
async def get_message(self) -> bytes:
return b"test message"
async def aclose(self) -> None:
pass
mock_ws = MockWebSocketConnection()
conn = P2PWebSocketConnection(mock_ws, is_secure=True)
# Test initial state
state = conn.conn_state()
assert state["transport"] == "websocket"
assert state["secure"] is True
assert state["bytes_read"] == 0
assert state["bytes_written"] == 0
assert state["total_bytes"] == 0
assert state["connection_duration"] >= 0
# Test byte tracking (we can't actually read/write with mock, but we can test the method)
# The actual byte tracking will be tested in integration tests
assert hasattr(conn, "_bytes_read")
assert hasattr(conn, "_bytes_written")
assert hasattr(conn, "_connection_start_time")
@pytest.mark.trio
async def test_concurrent_close_handling():
"""Test concurrent close handling similar to Go implementation."""
from libp2p.transport.websocket.connection import P2PWebSocketConnection
# Create a mock WebSocket connection that tracks close calls
class MockWebSocketConnection:
def __init__(self):
self.close_calls = 0
self.closed = False
async def send_message(self, data: bytes) -> None:
if self.closed:
raise Exception("Connection closed")
pass
async def get_message(self) -> bytes:
if self.closed:
raise Exception("Connection closed")
return b"test message"
async def aclose(self) -> None:
self.close_calls += 1
self.closed = True
mock_ws = MockWebSocketConnection()
conn = P2PWebSocketConnection(mock_ws, is_secure=False)
# Test that multiple close calls are handled gracefully
await conn.close()
await conn.close() # Second close should not raise an error
# The mock should only be closed once
assert mock_ws.close_calls == 1
assert mock_ws.closed is True
@pytest.mark.trio
async def test_zero_byte_write_handling():
"""Test zero-byte write handling similar to Go implementation."""
from libp2p.transport.websocket.connection import P2PWebSocketConnection
# Create a mock WebSocket connection that tracks write calls
class MockWebSocketConnection:
def __init__(self):
self.write_calls = []
async def send_message(self, data: bytes) -> None:
self.write_calls.append(len(data))
async def get_message(self) -> bytes:
return b"test message"
async def aclose(self) -> None:
pass
mock_ws = MockWebSocketConnection()
conn = P2PWebSocketConnection(mock_ws, is_secure=False)
# Test zero-byte write
await conn.write(b"")
assert 0 in mock_ws.write_calls
# Test normal write
await conn.write(b"hello")
assert 5 in mock_ws.write_calls
# Test multiple zero-byte writes
for _ in range(10):
await conn.write(b"")
# Should have 11 zero-byte writes total (1 initial + 10 in loop)
zero_byte_writes = [call for call in mock_ws.write_calls if call == 0]
assert len(zero_byte_writes) == 11
@pytest.mark.trio
async def test_websocket_transport_protocols():
"""Test that WebSocket transport reports correct protocols."""
upgrader = create_upgrader()
# transport = WebsocketTransport(upgrader) # Not used in this test
# Test that the transport can handle both WS and WSS protocols
ws_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/ws")
wss_maddr = Multiaddr("/ip4/127.0.0.1/tcp/8080/wss")
# Both should be valid WebSocket multiaddrs
assert is_valid_websocket_multiaddr(ws_maddr)
assert is_valid_websocket_multiaddr(wss_maddr)
# Both should be parseable
ws_parsed = parse_websocket_multiaddr(ws_maddr)
wss_parsed = parse_websocket_multiaddr(wss_maddr)
assert not ws_parsed.is_wss
assert wss_parsed.is_wss
@pytest.mark.trio
async def test_websocket_listener_addr_format():
"""Test WebSocket listener address format similar to Go implementation."""
upgrader = create_upgrader()
# Test WS listener
transport_ws = WebsocketTransport(upgrader)
async def dummy_handler_ws(conn):
await trio.sleep(0)
listener_ws = transport_ws.create_listener(dummy_handler_ws)
assert listener_ws._handshake_timeout == 15.0 # Default timeout
# Test WSS listener with TLS config
import ssl
tls_config = ssl.create_default_context()
transport_wss = WebsocketTransport(upgrader, tls_server_config=tls_config)
async def dummy_handler_wss(conn):
await trio.sleep(0)
listener_wss = transport_wss.create_listener(dummy_handler_wss)
assert listener_wss._tls_config is not None
assert listener_wss._handshake_timeout == 15.0
@pytest.mark.trio
async def test_sni_resolution_limitation():
"""Test SNI resolution limitation - Python multiaddr library doesn't support SNI protocol."""
upgrader = create_upgrader()
transport = WebsocketTransport(upgrader)
# Test that WSS addresses are returned unchanged (SNI resolution not supported)
wss_maddr = Multiaddr("/dns/example.com/tcp/1234/wss")
resolved = transport.resolve(wss_maddr)
assert len(resolved) == 1
assert resolved[0] == wss_maddr
# Test that non-WSS addresses are returned unchanged
ws_maddr = Multiaddr("/dns/example.com/tcp/1234/ws")
resolved = transport.resolve(ws_maddr)
assert len(resolved) == 1
assert resolved[0] == ws_maddr
# Test that IP addresses are returned unchanged
ip_maddr = Multiaddr("/ip4/127.0.0.1/tcp/1234/wss")
resolved = transport.resolve(ip_maddr)
assert len(resolved) == 1
assert resolved[0] == ip_maddr
@pytest.mark.trio
async def test_websocket_transport_can_dial():
"""Test WebSocket transport CanDial functionality similar to Go implementation."""
upgrader = create_upgrader()
# transport = WebsocketTransport(upgrader) # Not used in this test
# Test valid WebSocket addresses that should be dialable
valid_addresses = [
"/ip4/127.0.0.1/tcp/5555/ws",
"/ip4/127.0.0.1/tcp/5555/wss",
"/ip4/127.0.0.1/tcp/5555/tls/ws",
# Note: SNI addresses not supported by Python multiaddr library
]
for addr_str in valid_addresses:
maddr = Multiaddr(addr_str)
# All these should be valid WebSocket multiaddrs
assert is_valid_websocket_multiaddr(maddr), (
f"Address {addr_str} should be valid"
)
# Test invalid addresses that should not be dialable
invalid_addresses = [
"/ip4/127.0.0.1/tcp/5555", # No WebSocket protocol
"/ip4/127.0.0.1/udp/5555/ws", # Wrong transport protocol
]
for addr_str in invalid_addresses:
maddr = Multiaddr(addr_str)
# These should not be valid WebSocket multiaddrs
assert not is_valid_websocket_multiaddr(maddr), (
f"Address {addr_str} should be invalid"
)

516
tests/core/transport/test_websocket_p2p.py Normal file
View File

@ -0,0 +1,516 @@
#!/usr/bin/env python3
"""
Python-to-Python WebSocket peer-to-peer tests.
This module tests real WebSocket communication between two Python libp2p hosts,
including both WS and WSS (WebSocket Secure) scenarios.
"""
import pytest
from multiaddr import Multiaddr
import trio
from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.crypto.x25519 import create_new_key_pair as create_new_x25519_key_pair
from libp2p.custom_types import TProtocol
from libp2p.security.insecure.transport import PLAINTEXT_PROTOCOL_ID, InsecureTransport
from libp2p.security.noise.transport import (
PROTOCOL_ID as NOISE_PROTOCOL_ID,
Transport as NoiseTransport,
)
from libp2p.transport.websocket.multiaddr_utils import (
is_valid_websocket_multiaddr,
parse_websocket_multiaddr,
)
PING_PROTOCOL_ID = TProtocol("/ipfs/ping/1.0.0")
PING_LENGTH = 32
@pytest.mark.trio
async def test_websocket_p2p_plaintext():
"""Test Python-to-Python WebSocket communication with plaintext security."""
# Create two hosts with plaintext security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
# Host A (listener) - use only plaintext security
security_options_a = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer) - use only plaintext security
security_options_b = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test data
test_data = b"Hello WebSocket P2P!"
received_data = None
# Set up ping handler on host A
async def ping_handler(stream):
nonlocal received_data
received_data = await stream.read(len(test_data))
await stream.write(received_data) # Echo back
await stream.close()
host_a.set_stream_handler(PING_PROTOCOL_ID, ping_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WebSocket address
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
assert is_valid_websocket_multiaddr(ws_addr), "Invalid WebSocket multiaddr"
# Parse the WebSocket multiaddr
parsed = parse_websocket_multiaddr(ws_addr)
assert not parsed.is_wss, "Should be plain WebSocket, not WSS"
assert parsed.sni is None, "SNI should be None for plain WebSocket"
# Connect host B to host A
from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create stream and test communication
stream = await host_b.new_stream(host_a.get_id(), [PING_PROTOCOL_ID])
await stream.write(test_data)
response = await stream.read(len(test_data))
await stream.close()
# Verify communication
assert received_data == test_data, f"Expected {test_data}, got {received_data}"
assert response == test_data, f"Expected echo {test_data}, got {response}"
@pytest.mark.trio
async def test_websocket_p2p_noise():
"""Test Python-to-Python WebSocket communication with Noise security."""
# Create two hosts with Noise security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
noise_key_pair_a = create_new_x25519_key_pair()
noise_key_pair_b = create_new_x25519_key_pair()
# Host A (listener)
security_options_a = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_a,
noise_privkey=noise_key_pair_a.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer)
security_options_b = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_b,
noise_privkey=noise_key_pair_b.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test data
test_data = b"Hello WebSocket P2P with Noise!"
received_data = None
# Set up ping handler on host A
async def ping_handler(stream):
nonlocal received_data
received_data = await stream.read(len(test_data))
await stream.write(received_data) # Echo back
await stream.close()
host_a.set_stream_handler(PING_PROTOCOL_ID, ping_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WebSocket address
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
assert is_valid_websocket_multiaddr(ws_addr), "Invalid WebSocket multiaddr"
# Parse the WebSocket multiaddr
parsed = parse_websocket_multiaddr(ws_addr)
assert not parsed.is_wss, "Should be plain WebSocket, not WSS"
assert parsed.sni is None, "SNI should be None for plain WebSocket"
# Connect host B to host A
from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create stream and test communication
stream = await host_b.new_stream(host_a.get_id(), [PING_PROTOCOL_ID])
await stream.write(test_data)
response = await stream.read(len(test_data))
await stream.close()
# Verify communication
assert received_data == test_data, f"Expected {test_data}, got {received_data}"
assert response == test_data, f"Expected echo {test_data}, got {response}"
@pytest.mark.trio
async def test_websocket_p2p_libp2p_ping():
"""Test Python-to-Python WebSocket communication using libp2p ping protocol."""
# Create two hosts with Noise security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
noise_key_pair_a = create_new_x25519_key_pair()
noise_key_pair_b = create_new_x25519_key_pair()
# Host A (listener)
security_options_a = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_a,
noise_privkey=noise_key_pair_a.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer)
security_options_b = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_b,
noise_privkey=noise_key_pair_b.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Set up ping handler on host A (standard libp2p ping protocol)
async def ping_handler(stream):
# Read ping data (32 bytes)
ping_data = await stream.read(PING_LENGTH)
# Echo back the same data (pong)
await stream.write(ping_data)
await stream.close()
host_a.set_stream_handler(PING_PROTOCOL_ID, ping_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert len(listen_addrs) > 0
# Find the WebSocket address
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
# Connect host B to host A
from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create stream and test libp2p ping protocol
stream = await host_b.new_stream(host_a.get_id(), [PING_PROTOCOL_ID])
# Send ping (32 bytes as per libp2p ping protocol)
ping_data = b"\x01" * PING_LENGTH
await stream.write(ping_data)
# Receive pong (should be same 32 bytes)
pong_data = await stream.read(PING_LENGTH)
await stream.close()
# Verify ping-pong
assert pong_data == ping_data, (
f"Expected ping {ping_data}, got pong {pong_data}"
)
@pytest.mark.trio
async def test_websocket_p2p_multiple_streams():
"""Test Python-to-Python WebSocket communication with multiple concurrent streams."""
# Create two hosts with Noise security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
noise_key_pair_a = create_new_x25519_key_pair()
noise_key_pair_b = create_new_x25519_key_pair()
# Host A (listener)
security_options_a = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_a,
noise_privkey=noise_key_pair_a.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer)
security_options_b = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_b,
noise_privkey=noise_key_pair_b.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Test protocol
test_protocol = TProtocol("/test/multiple/streams/1.0.0")
received_data = []
# Set up handler on host A
async def test_handler(stream):
data = await stream.read(1024)
received_data.append(data)
await stream.write(data) # Echo back
await stream.close()
host_a.set_stream_handler(test_protocol, test_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
# Connect host B to host A
from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create multiple concurrent streams
num_streams = 5
test_data_list = [f"Stream {i} data".encode() for i in range(num_streams)]
async def create_stream_and_test(stream_id: int, data: bytes):
stream = await host_b.new_stream(host_a.get_id(), [test_protocol])
await stream.write(data)
response = await stream.read(len(data))
await stream.close()
return response
# Run all streams concurrently
tasks = [create_stream_and_test(i, test_data_list[i]) for i in range(num_streams)]
responses = []
for task in tasks:
responses.append(await task)
# Verify all communications
assert len(received_data) == num_streams, (
f"Expected {num_streams} received messages, got {len(received_data)}"
)
for i, (sent, received, response) in enumerate(
zip(test_data_list, received_data, responses)
):
assert received == sent, f"Stream {i}: Expected {sent}, got {received}"
assert response == sent, f"Stream {i}: Expected echo {sent}, got {response}"
@pytest.mark.trio
async def test_websocket_p2p_connection_state():
"""Test WebSocket connection state tracking and metadata."""
# Create two hosts with Noise security
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
noise_key_pair_a = create_new_x25519_key_pair()
noise_key_pair_b = create_new_x25519_key_pair()
# Host A (listener)
security_options_a = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_a,
noise_privkey=noise_key_pair_a.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
)
# Host B (dialer)
security_options_b = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair_b,
noise_privkey=noise_key_pair_b.private_key,
early_data=None,
with_noise_pipes=False,
)
}
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(),
)
# Set up handler on host A
async def test_handler(stream):
# Read some data
await stream.read(1024)
# Write some data back
await stream.write(b"Response data")
await stream.close()
host_a.set_stream_handler(PING_PROTOCOL_ID, test_handler)
# Start both hosts
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
ws_addr = None
for addr in listen_addrs:
if "/ws" in str(addr):
ws_addr = addr
break
assert ws_addr is not None, "No WebSocket listen address found"
# Connect host B to host A
from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(ws_addr)
await host_b.connect(peer_info)
# Create stream and test communication
stream = await host_b.new_stream(host_a.get_id(), [PING_PROTOCOL_ID])
await stream.write(b"Test data for connection state")
response = await stream.read(1024)
await stream.close()
# Verify response
assert response == b"Response data", f"Expected 'Response data', got {response}"
# Test connection state (if available)
# Note: This tests the connection state tracking we implemented
connections = host_b.get_network().connections
assert len(connections) > 0, "Should have at least one connection"
# Get the connection to host A
conn_to_a = None
for peer_id, conn in connections.items():
if peer_id == host_a.get_id():
conn_to_a = conn
break
assert conn_to_a is not None, "Should have connection to host A"
# Test that the connection has the expected properties
assert hasattr(conn_to_a, "muxed_conn"), "Connection should have muxed_conn"
assert hasattr(conn_to_a.muxed_conn, "conn"), (
"Muxed connection should have underlying conn"
)
# If the underlying connection is our WebSocket connection, test its state
underlying_conn = conn_to_a.muxed_conn.conn
if hasattr(underlying_conn, "conn_state"):
state = underlying_conn.conn_state()
assert "connection_start_time" in state, (
"Connection state should include start time"
)
assert "bytes_read" in state, "Connection state should include bytes read"
assert "bytes_written" in state, (
"Connection state should include bytes written"
)
assert state["bytes_read"] > 0, "Should have read some bytes"
assert state["bytes_written"] > 0, "Should have written some bytes"

103
tests/interop/test_js_ws_ping.py
View File

@ -28,24 +28,69 @@ async def test_ping_with_js_node():
js_node_dir = os.path.join(os.path.dirname(__file__), "js_libp2p", "js_node", "src")
script_name = "./ws_ping_node.mjs"
# Debug: Check if JS node directory exists
print(f"JS Node Directory: {js_node_dir}")
print(f"JS Node Directory exists: {os.path.exists(js_node_dir)}")
if os.path.exists(js_node_dir):
print(f"JS Node Directory contents: {os.listdir(js_node_dir)}")
script_path = os.path.join(js_node_dir, script_name)
print(f"Script path: {script_path}")
print(f"Script exists: {os.path.exists(script_path)}")
if os.path.exists(script_path):
with open(script_path) as f:
script_content = f.read()
print(f"Script content (first 500 chars): {script_content[:500]}...")
# Debug: Check if npm is available
try:
subprocess.run(
npm_version = subprocess.run(
["npm", "--version"],
capture_output=True,
text=True,
check=True,
)
print(f"NPM version: {npm_version.stdout.strip()}")
except (subprocess.CalledProcessError, FileNotFoundError) as e:
print(f"NPM not available: {e}")
# Debug: Check if node is available
try:
node_version = subprocess.run(
["node", "--version"],
capture_output=True,
text=True,
check=True,
)
print(f"Node version: {node_version.stdout.strip()}")
except (subprocess.CalledProcessError, FileNotFoundError) as e:
print(f"Node not available: {e}")
try:
print(f"Running npm install in {js_node_dir}...")
npm_install_result = subprocess.run(
["npm", "install"],
cwd=js_node_dir,
check=True,
capture_output=True,
text=True,
)
print(f"NPM install stdout: {npm_install_result.stdout}")
print(f"NPM install stderr: {npm_install_result.stderr}")
except (subprocess.CalledProcessError, FileNotFoundError) as e:
print(f"NPM install failed: {e}")
pytest.fail(f"Failed to run 'npm install': {e}")
# Launch the JS libp2p node (long-running)
print(f"Launching JS node: node {script_name} in {js_node_dir}")
proc = await open_process(
["node", script_name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=js_node_dir,
)
print(f"JS node process started with PID: {proc.pid}")
assert proc.stdout is not None, "stdout pipe missing"
assert proc.stderr is not None, "stderr pipe missing"
stdout = proc.stdout
@ -53,18 +98,26 @@ async def test_ping_with_js_node():
try:
# Read first two lines (PeerID and multiaddr)
print("Waiting for JS node to output PeerID and multiaddr...")
buffer = b""
with trio.fail_after(30):
while buffer.count(b"\n") < 2:
chunk = await stdout.receive_some(1024)
if not chunk:
print("No more data from JS node stdout")
break
buffer += chunk
print(f"Received chunk: {chunk}")
print(f"Total buffer received: {buffer}")
lines = [line for line in buffer.decode().splitlines() if line.strip()]
print(f"Parsed lines: {lines}")
if len(lines) < 2:
print("Not enough lines from JS node, checking stderr...")
stderr_output = await stderr.receive_some(2048)
stderr_output = stderr_output.decode()
print(f"JS node stderr: {stderr_output}")
pytest.fail(
"JS node did not produce expected PeerID and multiaddr.\n"
f"Stdout: {buffer.decode()!r}\n"
@ -78,13 +131,17 @@ async def test_ping_with_js_node():
print(f"JS Node Peer ID: {peer_id_line}")
print(f"JS Node Address: {addr_line}")
print(f"All JS Node lines: {lines}")
print(f"Parsed multiaddr: {maddr}")
# Set up Python host
print("Setting up Python host...")
key_pair = create_new_key_pair()
py_peer_id = ID.from_pubkey(key_pair.public_key)
peer_store = PeerStore()
peer_store.add_key_pair(py_peer_id, key_pair)
print(f"Python Peer ID: {py_peer_id}")
# Use only plaintext security to match the JavaScript node
upgrader = TransportUpgrader(
secure_transports_by_protocol={
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair)
@ -92,20 +149,41 @@ async def test_ping_with_js_node():
muxer_transports_by_protocol={TProtocol("/yamux/1.0.0"): Yamux},
)
transport = WebsocketTransport(upgrader)
print(f"WebSocket transport created: {transport}")
swarm = Swarm(py_peer_id, peer_store, upgrader, transport)
host = BasicHost(swarm)
print(f"Python host created: {host}")
# Connect to JS node
peer_info = PeerInfo(peer_id, [maddr])
print(f"Python trying to connect to: {peer_info}")
print(f"Peer info addresses: {peer_info.addrs}")
# Test WebSocket multiaddr validation
from libp2p.transport.websocket.multiaddr_utils import (
is_valid_websocket_multiaddr,
parse_websocket_multiaddr,
)
print(f"Is valid WebSocket multiaddr: {is_valid_websocket_multiaddr(maddr)}")
try:
parsed = parse_websocket_multiaddr(maddr)
print(
f"Parsed WebSocket multiaddr: is_wss={parsed.is_wss}, sni={parsed.sni}, rest_multiaddr={parsed.rest_multiaddr}"
)
except Exception as e:
print(f"Failed to parse WebSocket multiaddr: {e}")
await trio.sleep(1)
try:
print("Attempting to connect to JS node...")
await host.connect(peer_info)
print("Successfully connected to JS node!")
except SwarmException as e:
underlying_error = e.__cause__
print(f"Connection failed with SwarmException: {e}")
print(f"Underlying error: {underlying_error}")
pytest.fail(
"Connection failed with SwarmException.\n"
f"THE REAL ERROR IS: {underlying_error!r}\n"
@ -119,7 +197,26 @@ async def test_ping_with_js_node():
data = await stream.read(4)
assert data == b"pong"
print("Closing Python host...")
await host.close()
print("Python host closed successfully")
finally:
proc.send_signal(signal.SIGTERM)
print(f"Terminating JS node process (PID: {proc.pid})...")
try:
proc.send_signal(signal.SIGTERM)
print("SIGTERM sent to JS node process")
await trio.sleep(1) # Give it time to terminate gracefully
if proc.poll() is None:
print("JS node process still running, sending SIGKILL...")
proc.send_signal(signal.SIGKILL)
await trio.sleep(0.5)
except Exception as e:
print(f"Error terminating JS node process: {e}")
# Check if process is still running
if proc.poll() is None:
print("WARNING: JS node process is still running!")
else:
print(f"JS node process terminated with exit code: {proc.poll()}")
await trio.sleep(0)