varun-r-mallya/py-libp2p
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/py-libp2p.git synced 2026-02-12 16:10:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix type errors and linting issues

Browse Source 
- Fix type annotation errors in transport_registry.py and __init__.py
- Fix line length violations in test files (E501 errors)
- Fix missing return type annotations
- Fix cryptography NameAttribute type errors with type: ignore
- Fix ExceptionGroup import for cross-version compatibility
- Fix test failure in test_wss_listen_without_tls_config by handling ExceptionGroup
- Fix len() calls with None arguments in test_tcp_data_transfer.py
- Fix missing attribute access errors on interface types
- Fix boolean type expectation errors in test_js_ws_ping.py
- Fix nursery context manager type errors

All tests now pass and linting is clean.
This commit is contained in:
acul71
2025-09-08 04:18:10 +02:00
parent afe6da5db2
commit f4d5a44521
15 changed files with 1028 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
debug_websocket_url.py
View File

@ -1,65 +0,0 @@
#!/usr/bin/env python3
"""
Debug script to test WebSocket URL construction and basic connection.
"""
import logging
from multiaddr import Multiaddr
from libp2p.transport.websocket.multiaddr_utils import parse_websocket_multiaddr
# Configure logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
async def test_websocket_url():
"""Test WebSocket URL construction."""
# Test multiaddr from your JS node
maddr_str = "/ip4/127.0.0.1/tcp/35391/ws/p2p/12D3KooWQh7p5xP2ppr3CrhUFsawmsKNe9jgDbacQdWCYpuGfMVN"
maddr = Multiaddr(maddr_str)
logger.info(f"Testing multiaddr: {maddr}")
# Parse WebSocket multiaddr
parsed = parse_websocket_multiaddr(maddr)
logger.info(
f"Parsed: is_wss={parsed.is_wss}, sni={parsed.sni}, rest_multiaddr={parsed.rest_multiaddr}"
)
# Construct WebSocket URL
if parsed.is_wss:
protocol = "wss"
else:
protocol = "ws"
# Extract host and port from rest_multiaddr
host = parsed.rest_multiaddr.value_for_protocol("ip4")
port = parsed.rest_multiaddr.value_for_protocol("tcp")
websocket_url = f"{protocol}://{host}:{port}/"
logger.info(f"WebSocket URL: {websocket_url}")
# Test basic WebSocket connection
try:
from trio_websocket import open_websocket_url
logger.info("Testing basic WebSocket connection...")
async with open_websocket_url(websocket_url) as ws:
logger.info("✅ WebSocket connection successful!")
# Send a simple message
await ws.send_message(b"test")
logger.info("✅ Message sent successfully!")
except Exception as e:
logger.error(f"❌ WebSocket connection failed: {e}")
import traceback
logger.error(f"Traceback: {traceback.format_exc()}")
if __name__ == "__main__":
import trio
trio.run(test_websocket_url)

446
examples/test_tcp_data_transfer.py Normal file
View File

@ -0,0 +1,446 @@
#!/usr/bin/env python3
"""
TCP P2P Data Transfer Test
This test proves that TCP peer-to-peer data transfer works correctly in libp2p.
This serves as a baseline to compare with WebSocket tests.
"""
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.custom_types import TProtocol
from libp2p.peer.peerinfo import info_from_p2p_addr
from libp2p.security.insecure.transport import PLAINTEXT_PROTOCOL_ID, InsecureTransport
# Test protocol for data exchange
TCP_DATA_PROTOCOL = TProtocol("/test/tcp-data-exchange/1.0.0")
async def create_tcp_host_pair():
"""Create a pair of hosts configured for TCP communication."""
# Create key pairs
key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair()
# Create security options (using plaintext for simplicity)
def security_options(kp):
return {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=kp, secure_bytes_provider=None, peerstore=None
)
}
# Host A (listener) - TCP transport (default)
host_a = new_host(
key_pair=key_pair_a,
sec_opt=security_options(key_pair_a),
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")],
)
# Host B (dialer) - TCP transport (default)
host_b = new_host(
key_pair=key_pair_b,
sec_opt=security_options(key_pair_b),
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")],
)
return host_a, host_b
@pytest.mark.trio
async def test_tcp_basic_connection():
"""Test basic TCP connection establishment."""
host_a, host_b = await create_tcp_host_pair()
connection_established = False
async def connection_handler(stream):
nonlocal connection_established
connection_established = True
await stream.close()
host_a.set_stream_handler(TCP_DATA_PROTOCOL, connection_handler)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert listen_addrs, "Host A should have listen addresses"
# Extract TCP address
tcp_addr = None
for addr in listen_addrs:
if "/tcp/" in str(addr) and "/ws" not in str(addr):
tcp_addr = addr
break
assert tcp_addr, f"No TCP address found in {listen_addrs}"
print(f"🔗 Host A listening on: {tcp_addr}")
# Create peer info for host A
peer_info = info_from_p2p_addr(tcp_addr)
# Host B connects to host A
await host_b.connect(peer_info)
print("✅ TCP connection established")
# Open a stream to test the connection
stream = await host_b.new_stream(peer_info.peer_id, [TCP_DATA_PROTOCOL])
await stream.close()
# Wait a bit for the handler to be called
await trio.sleep(0.1)
assert connection_established, "TCP connection handler should have been called"
print("✅ TCP basic connection test successful!")
@pytest.mark.trio
async def test_tcp_data_transfer():
"""Test TCP peer-to-peer data transfer."""
host_a, host_b = await create_tcp_host_pair()
# Test data
test_data = b"Hello TCP P2P Data Transfer! This is a test message."
received_data = None
transfer_complete = trio.Event()
async def data_handler(stream):
nonlocal received_data
try:
# Read the incoming data
received_data = await stream.read(len(test_data))
# Echo it back to confirm successful transfer
await stream.write(received_data)
await stream.close()
transfer_complete.set()
except Exception as e:
print(f"Handler error: {e}")
transfer_complete.set()
host_a.set_stream_handler(TCP_DATA_PROTOCOL, data_handler)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert listen_addrs, "Host A should have listen addresses"
# Extract TCP address
tcp_addr = None
for addr in listen_addrs:
if "/tcp/" in str(addr) and "/ws" not in str(addr):
tcp_addr = addr
break
assert tcp_addr, f"No TCP address found in {listen_addrs}"
print(f"🔗 Host A listening on: {tcp_addr}")
# Create peer info for host A
peer_info = info_from_p2p_addr(tcp_addr)
# Host B connects to host A
await host_b.connect(peer_info)
print("✅ TCP connection established")
# Open a stream for data transfer
stream = await host_b.new_stream(peer_info.peer_id, [TCP_DATA_PROTOCOL])
print("✅ TCP stream opened")
# Send test data
await stream.write(test_data)
print(f"📤 Sent data: {test_data}")
# Read echoed data back
echoed_data = await stream.read(len(test_data))
print(f"📥 Received echo: {echoed_data}")
await stream.close()
# Wait for transfer to complete
with trio.fail_after(5.0): # 5 second timeout
await transfer_complete.wait()
# Verify data transfer
assert received_data == test_data, (
f"Data mismatch: {received_data} != {test_data}"
)
assert echoed_data == test_data, f"Echo mismatch: {echoed_data} != {test_data}"
print("✅ TCP P2P data transfer successful!")
print(f" Original: {test_data}")
print(f" Received: {received_data}")
print(f" Echoed: {echoed_data}")
@pytest.mark.trio
async def test_tcp_large_data_transfer():
"""Test TCP with larger data payloads."""
host_a, host_b = await create_tcp_host_pair()
# Large test data (10KB)
test_data = b"TCP Large Data Test! " * 500 # ~10KB
received_data = None
transfer_complete = trio.Event()
async def large_data_handler(stream):
nonlocal received_data
try:
# Read data in chunks
chunks = []
total_received = 0
expected_size = len(test_data)
while total_received < expected_size:
chunk = await stream.read(min(1024, expected_size - total_received))
if not chunk:
break
chunks.append(chunk)
total_received += len(chunk)
received_data = b"".join(chunks)
# Send back confirmation
await stream.write(b"RECEIVED_OK")
await stream.close()
transfer_complete.set()
except Exception as e:
print(f"Large data handler error: {e}")
transfer_complete.set()
host_a.set_stream_handler(TCP_DATA_PROTOCOL, large_data_handler)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")]),
host_b.run(listen_addrs=[]),
):
# Get host A's listen address
listen_addrs = host_a.get_addrs()
assert listen_addrs, "Host A should have listen addresses"
# Extract TCP address
tcp_addr = None
for addr in listen_addrs:
if "/tcp/" in str(addr) and "/ws" not in str(addr):
tcp_addr = addr
break
assert tcp_addr, f"No TCP address found in {listen_addrs}"
print(f"🔗 Host A listening on: {tcp_addr}")
print(f"📊 Test data size: {len(test_data)} bytes")
# Create peer info for host A
peer_info = info_from_p2p_addr(tcp_addr)
# Host B connects to host A
await host_b.connect(peer_info)
print("✅ TCP connection established")
# Open a stream for data transfer
stream = await host_b.new_stream(peer_info.peer_id, [TCP_DATA_PROTOCOL])
print("✅ TCP stream opened")
# Send large test data in chunks
chunk_size = 1024
sent_bytes = 0
for i in range(0, len(test_data), chunk_size):
chunk = test_data[i : i + chunk_size]
await stream.write(chunk)
sent_bytes += len(chunk)
if sent_bytes % (chunk_size * 4) == 0: # Progress every 4KB
print(f"📤 Sent {sent_bytes}/{len(test_data)} bytes")
print(f"📤 Sent all {len(test_data)} bytes")
# Read confirmation
confirmation = await stream.read(1024)
print(f"📥 Received confirmation: {confirmation}")
await stream.close()
# Wait for transfer to complete
with trio.fail_after(10.0): # 10 second timeout for large data
await transfer_complete.wait()
# Verify data transfer
assert received_data is not None, "No data was received"
assert received_data == test_data, (
"Large data transfer failed:"
+ f" sizes {len(received_data)} != {len(test_data)}"
)
assert confirmation == b"RECEIVED_OK", f"Confirmation failed: {confirmation}"
print("✅ TCP large data transfer successful!")
print(f" Data size: {len(test_data)} bytes")
print(f" Received: {len(received_data)} bytes")
print(f" Match: {received_data == test_data}")
@pytest.mark.trio
async def test_tcp_bidirectional_transfer():
"""Test bidirectional data transfer over TCP."""
host_a, host_b = await create_tcp_host_pair()
# Test data
data_a_to_b = b"Message from Host A to Host B via TCP"
data_b_to_a = b"Response from Host B to Host A via TCP"
received_on_a = None
received_on_b = None
transfer_complete_a = trio.Event()
transfer_complete_b = trio.Event()
async def handler_a(stream):
nonlocal received_on_a
try:
# Read data from B
received_on_a = await stream.read(len(data_b_to_a))
print(f"🅰️ Host A received: {received_on_a}")
await stream.close()
transfer_complete_a.set()
except Exception as e:
print(f"Handler A error: {e}")
transfer_complete_a.set()
async def handler_b(stream):
nonlocal received_on_b
try:
# Read data from A
received_on_b = await stream.read(len(data_a_to_b))
print(f"🅱️ Host B received: {received_on_b}")
await stream.close()
transfer_complete_b.set()
except Exception as e:
print(f"Handler B error: {e}")
transfer_complete_b.set()
# Set up handlers on both hosts
protocol_a_to_b = TProtocol("/test/tcp-a-to-b/1.0.0")
protocol_b_to_a = TProtocol("/test/tcp-b-to-a/1.0.0")
host_a.set_stream_handler(protocol_b_to_a, handler_a)
host_b.set_stream_handler(protocol_a_to_b, handler_b)
async with (
host_a.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")]),
host_b.run(listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")]),
):
# Get addresses
addrs_a = host_a.get_addrs()
addrs_b = host_b.get_addrs()
assert addrs_a and addrs_b, "Both hosts should have addresses"
# Extract TCP addresses
tcp_addr_a = next(
(
addr
for addr in addrs_a
if "/tcp/" in str(addr) and "/ws" not in str(addr)
),
None,
)
tcp_addr_b = next(
(
addr
for addr in addrs_b
if "/tcp/" in str(addr) and "/ws" not in str(addr)
),
None,
)
assert tcp_addr_a and tcp_addr_b, (
f"TCP addresses not found: A={addrs_a}, B={addrs_b}"
)
print(f"🔗 Host A listening on: {tcp_addr_a}")
print(f"🔗 Host B listening on: {tcp_addr_b}")
# Create peer infos
peer_info_a = info_from_p2p_addr(tcp_addr_a)
peer_info_b = info_from_p2p_addr(tcp_addr_b)
# Establish connections
await host_b.connect(peer_info_a)
await host_a.connect(peer_info_b)
print("✅ Bidirectional TCP connections established")
# Send data A -> B
stream_a_to_b = await host_a.new_stream(peer_info_b.peer_id, [protocol_a_to_b])
await stream_a_to_b.write(data_a_to_b)
print(f"📤 A->B: {data_a_to_b}")
await stream_a_to_b.close()
# Send data B -> A
stream_b_to_a = await host_b.new_stream(peer_info_a.peer_id, [protocol_b_to_a])
await stream_b_to_a.write(data_b_to_a)
print(f"📤 B->A: {data_b_to_a}")
await stream_b_to_a.close()
# Wait for both transfers to complete
with trio.fail_after(5.0):
await transfer_complete_a.wait()
await transfer_complete_b.wait()
# Verify bidirectional transfer
assert received_on_a == data_b_to_a, f"A received wrong data: {received_on_a}"
assert received_on_b == data_a_to_b, f"B received wrong data: {received_on_b}"
print("✅ TCP bidirectional data transfer successful!")
print(f" A->B: {data_a_to_b}")
print(f" B->A: {data_b_to_a}")
print(f" ✓ A got: {received_on_a}")
print(f" ✓ B got: {received_on_b}")
if __name__ == "__main__":
# Run tests directly
import logging
logging.basicConfig(level=logging.INFO)
print("🧪 Running TCP P2P Data Transfer Tests")
print("=" * 50)
async def run_all_tcp_tests():
try:
print("\n1. Testing basic TCP connection...")
await test_tcp_basic_connection()
except Exception as e:
print(f"❌ Basic TCP connection test failed: {e}")
return
try:
print("\n2. Testing TCP data transfer...")
await test_tcp_data_transfer()
except Exception as e:
print(f"❌ TCP data transfer test failed: {e}")
return
try:
print("\n3. Testing TCP large data transfer...")
await test_tcp_large_data_transfer()
except Exception as e:
print(f"❌ TCP large data transfer test failed: {e}")
return
try:
print("\n4. Testing TCP bidirectional transfer...")
await test_tcp_bidirectional_transfer()
except Exception as e:
print(f"❌ TCP bidirectional transfer test failed: {e}")
return
print("\n" + "=" * 50)
print("🏁 TCP P2P Tests Complete - All Tests PASSED!")
trio.run(run_all_tcp_tests)

27
libp2p/__init__.py
View File

@ -1,6 +1,7 @@
"""Libp2p Python implementation.""" """Libp2p Python implementation."""
import logging import logging
import ssl
from libp2p.transport.quic.utils import is_quic_multiaddr from libp2p.transport.quic.utils import is_quic_multiaddr
from typing import Any from typing import Any
@ -179,6 +180,8 @@ def new_swarm(
enable_quic: bool = False, enable_quic: bool = False,
retry_config: Optional["RetryConfig"] = None, retry_config: Optional["RetryConfig"] = None,
connection_config: ConnectionConfig | QUICTransportConfig | None = None, connection_config: ConnectionConfig | QUICTransportConfig | None = None,
tls_client_config: ssl.SSLContext | None = None,
tls_server_config: ssl.SSLContext | None = None,
) -> INetworkService: ) -> INetworkService:
""" """
Create a swarm instance based on the parameters. Create a swarm instance based on the parameters.
@ -190,7 +193,9 @@ def new_swarm(
:param muxer_preference: optional explicit muxer preference :param muxer_preference: optional explicit muxer preference
:param listen_addrs: optional list of multiaddrs to listen on :param listen_addrs: optional list of multiaddrs to listen on
:param enable_quic: enable quic for transport :param enable_quic: enable quic for transport
:param quic_transport_opt: options for transport :param connection_config: options for transport configuration
:param tls_client_config: optional TLS configuration for WebSocket client connections (WSS)
:param tls_server_config: optional TLS configuration for WebSocket server connections (WSS)
:return: return a default swarm instance :return: return a default swarm instance
Note: Yamux (/yamux/1.0.0) is the preferred stream multiplexer Note: Yamux (/yamux/1.0.0) is the preferred stream multiplexer
@ -249,14 +254,18 @@ def new_swarm(
else: else:
# Use the first address to determine transport type # Use the first address to determine transport type
addr = listen_addrs[0] addr = listen_addrs[0]
transport_maybe = create_transport_for_multiaddr(addr, upgrader) transport_maybe = create_transport_for_multiaddr(
addr,
upgrader,
private_key=key_pair.private_key,
tls_client_config=tls_client_config,
tls_server_config=tls_server_config
)
if transport_maybe is None: if transport_maybe is None:
# Fallback to TCP if no specific transport found # Fallback to TCP if no specific transport found
if addr.__contains__("tcp"): if addr.__contains__("tcp"):
transport = TCP() transport = TCP()
elif addr.__contains__("quic"):
raise ValueError("QUIC not yet supported")
else: else:
supported_protocols = get_supported_transport_protocols() supported_protocols = get_supported_transport_protocols()
raise ValueError( raise ValueError(
@ -293,6 +302,8 @@ def new_host(
negotiate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT, negotiate_timeout: int = DEFAULT_NEGOTIATE_TIMEOUT,
enable_quic: bool = False, enable_quic: bool = False,
quic_transport_opt: QUICTransportConfig | None = None, quic_transport_opt: QUICTransportConfig | None = None,
tls_client_config: ssl.SSLContext | None = None,
tls_server_config: ssl.SSLContext | None = None,
) -> IHost: ) -> IHost:
""" """
Create a new libp2p host based on the given parameters. Create a new libp2p host based on the given parameters.
@ -307,7 +318,9 @@ def new_host(
:param enable_mDNS: whether to enable mDNS discovery :param enable_mDNS: whether to enable mDNS discovery
:param bootstrap: optional list of bootstrap peer addresses as strings :param bootstrap: optional list of bootstrap peer addresses as strings
:param enable_quic: optinal choice to use QUIC for transport :param enable_quic: optinal choice to use QUIC for transport
:param transport_opt: optional configuration for quic transport :param quic_transport_opt: optional configuration for quic transport
:param tls_client_config: optional TLS configuration for WebSocket client connections (WSS)
:param tls_server_config: optional TLS configuration for WebSocket server connections (WSS)
:return: return a host instance :return: return a host instance
""" """
@ -322,7 +335,9 @@ def new_host(
peerstore_opt=peerstore_opt, peerstore_opt=peerstore_opt,
muxer_preference=muxer_preference, muxer_preference=muxer_preference,
listen_addrs=listen_addrs, listen_addrs=listen_addrs,
connection_config=quic_transport_opt if enable_quic else None connection_config=quic_transport_opt if enable_quic else None,
tls_client_config=tls_client_config,
tls_server_config=tls_server_config
) )
if disc_opt is not None: if disc_opt is not None:

4
libp2p/transport/__init__.py
View File

@ -1,3 +1,5 @@
from typing import Any
from .tcp.tcp import TCP from .tcp.tcp import TCP
from .websocket.transport import WebsocketTransport from .websocket.transport import WebsocketTransport
from .transport_registry import ( from .transport_registry import (
@ -10,7 +12,7 @@ from .transport_registry import (
from .upgrader import TransportUpgrader from .upgrader import TransportUpgrader
from libp2p.abc import ITransport from libp2p.abc import ITransport
def create_transport(protocol: str, upgrader: TransportUpgrader | None = None, **kwargs) -> ITransport: def create_transport(protocol: str, upgrader: TransportUpgrader | None = None, **kwargs: Any) -> ITransport:
""" """
Convenience function to create a transport instance. Convenience function to create a transport instance.

61
libp2p/transport/transport_registry.py
View File

@ -2,6 +2,7 @@
Transport registry for dynamic transport selection based on multiaddr protocols. Transport registry for dynamic transport selection based on multiaddr protocols.
""" """
from collections.abc import Callable
import logging import logging
from typing import Any from typing import Any
@ -16,8 +17,21 @@ from libp2p.transport.websocket.multiaddr_utils import (
) )
# Import QUIC utilities here to avoid circular imports
def _get_quic_transport() -> Any:
from libp2p.transport.quic.transport import QUICTransport
return QUICTransport
def _get_quic_validation() -> Callable[[Multiaddr], bool]:
from libp2p.transport.quic.utils import is_quic_multiaddr
return is_quic_multiaddr
# Import WebsocketTransport here to avoid circular imports # Import WebsocketTransport here to avoid circular imports
def _get_websocket_transport(): def _get_websocket_transport() -> Any:
from libp2p.transport.websocket.transport import WebsocketTransport from libp2p.transport.websocket.transport import WebsocketTransport
return WebsocketTransport return WebsocketTransport
@ -85,6 +99,11 @@ class TransportRegistry:
self.register_transport("ws", WebsocketTransport) self.register_transport("ws", WebsocketTransport)
self.register_transport("wss", WebsocketTransport) self.register_transport("wss", WebsocketTransport)
# Register QUIC transport for /quic and /quic-v1 protocols
QUICTransport = _get_quic_transport()
self.register_transport("quic", QUICTransport)
self.register_transport("quic-v1", QUICTransport)
def register_transport( def register_transport(
self, protocol: str, transport_class: type[ITransport] self, protocol: str, transport_class: type[ITransport]
) -> None: ) -> None:
@ -137,7 +156,22 @@ class TransportRegistry:
return None return None
# Use explicit WebsocketTransport to avoid type issues # Use explicit WebsocketTransport to avoid type issues
WebsocketTransport = _get_websocket_transport() WebsocketTransport = _get_websocket_transport()
return WebsocketTransport(upgrader) return WebsocketTransport(
upgrader,
tls_client_config=kwargs.get("tls_client_config"),
tls_server_config=kwargs.get("tls_server_config"),
handshake_timeout=kwargs.get("handshake_timeout", 15.0),
)
elif protocol in ["quic", "quic-v1"]:
# QUIC transport requires private_key
private_key = kwargs.get("private_key")
if private_key is None:
logger.warning(f"QUIC transport '{protocol}' requires private_key")
return None
# Use explicit QUICTransport to avoid type issues
QUICTransport = _get_quic_transport()
config = kwargs.get("config")
return QUICTransport(private_key, config)
else: else:
# TCP transport doesn't require upgrader # TCP transport doesn't require upgrader
return transport_class() return transport_class()
@ -161,13 +195,15 @@ def register_transport(protocol: str, transport_class: type[ITransport]) -> None
def create_transport_for_multiaddr( def create_transport_for_multiaddr(
maddr: Multiaddr, upgrader: TransportUpgrader maddr: Multiaddr, upgrader: TransportUpgrader, **kwargs: Any
) -> ITransport | None: ) -> ITransport | None:
""" """
Create the appropriate transport for a given multiaddr. Create the appropriate transport for a given multiaddr.
:param maddr: The multiaddr to create transport for :param maddr: The multiaddr to create transport for
:param upgrader: The transport upgrader instance :param upgrader: The transport upgrader instance
:param kwargs: Additional arguments for transport construction
(e.g., private_key for QUIC)
:return: Transport instance or None if no suitable transport found :return: Transport instance or None if no suitable transport found
""" """
try: try:
@ -176,7 +212,20 @@ def create_transport_for_multiaddr(
# Check for supported transport protocols in order of preference # Check for supported transport protocols in order of preference
# We need to validate that the multiaddr structure is valid for our transports # We need to validate that the multiaddr structure is valid for our transports
if "ws" in protocols or "wss" in protocols or "tls" in protocols: if "quic" in protocols or "quic-v1" in protocols:
# For QUIC, we need a valid structure like:
# /ip4/127.0.0.1/udp/4001/quic
# /ip4/127.0.0.1/udp/4001/quic-v1
is_quic_multiaddr = _get_quic_validation()
if is_quic_multiaddr(maddr):
# Determine QUIC version
if "quic-v1" in protocols:
return _global_registry.create_transport(
"quic-v1", upgrader, **kwargs
)
else:
return _global_registry.create_transport("quic", upgrader, **kwargs)
elif "ws" in protocols or "wss" in protocols or "tls" in protocols:
# For WebSocket, we need a valid structure like: # For WebSocket, we need a valid structure like:
# /ip4/127.0.0.1/tcp/8080/ws (insecure) # /ip4/127.0.0.1/tcp/8080/ws (insecure)
# /ip4/127.0.0.1/tcp/8080/wss (secure) # /ip4/127.0.0.1/tcp/8080/wss (secure)
@ -185,9 +234,9 @@ def create_transport_for_multiaddr(
if is_valid_websocket_multiaddr(maddr): if is_valid_websocket_multiaddr(maddr):
# Determine if this is a secure WebSocket connection # Determine if this is a secure WebSocket connection
if "wss" in protocols or "tls" in protocols: if "wss" in protocols or "tls" in protocols:
return _global_registry.create_transport("wss", upgrader) return _global_registry.create_transport("wss", upgrader, **kwargs)
else: else:
return _global_registry.create_transport("ws", upgrader) return _global_registry.create_transport("ws", upgrader, **kwargs)
elif "tcp" in protocols: elif "tcp" in protocols:
# For TCP, we need a valid structure like /ip4/127.0.0.1/tcp/8080 # For TCP, we need a valid structure like /ip4/127.0.0.1/tcp/8080
# Check if the multiaddr has proper TCP structure # Check if the multiaddr has proper TCP structure

142
libp2p/transport/websocket/connection.py
View File

@ -35,11 +35,9 @@ class P2PWebSocketConnection(ReadWriteCloser):
raise IOException("Connection is closed") raise IOException("Connection is closed")
try: try:
logger.debug(f"WebSocket writing {len(data)} bytes")
# Send as a binary WebSocket message # Send as a binary WebSocket message
await self._ws_connection.send_message(data) await self._ws_connection.send_message(data)
self._bytes_written += len(data) self._bytes_written += len(data)
logger.debug(f"WebSocket wrote {len(data)} bytes successfully")
except Exception as e: except Exception as e:
logger.error(f"WebSocket write failed: {e}") logger.error(f"WebSocket write failed: {e}")
raise IOException from e raise IOException from e
@ -48,95 +46,70 @@ class P2PWebSocketConnection(ReadWriteCloser):
""" """
Read up to n bytes (if n is given), else read up to 64KiB. Read up to n bytes (if n is given), else read up to 64KiB.
This implementation provides byte-level access to WebSocket messages, This implementation provides byte-level access to WebSocket messages,
which is required for Noise protocol handshake. which is required for libp2p protocol compatibility.
For WebSocket compatibility with libp2p protocols, this method:
1. Buffers incoming WebSocket messages
2. Returns exactly the requested number of bytes when n is specified
3. Accumulates multiple WebSocket messages if needed to satisfy the request
4. Returns empty bytes (not raises) when connection is closed and no data
available
""" """
if self._closed: if self._closed:
raise IOException("Connection is closed") raise IOException("Connection is closed")
async with self._read_lock: async with self._read_lock:
try: try:
logger.debug( # If n is None, read at least one message and return all buffered data
f"WebSocket read requested: n={n}, "
f"buffer_size={len(self._read_buffer)}"
)
# If we have buffered data, return it
if self._read_buffer:
if n is None:
result = self._read_buffer
self._read_buffer = b""
self._bytes_read += len(result)
logger.debug(
f"WebSocket read returning all buffered data: "
f"{len(result)} bytes"
)
return result
else:
if len(self._read_buffer) >= n:
result = self._read_buffer[:n]
self._read_buffer = self._read_buffer[n:]
self._bytes_read += len(result)
logger.debug(
f"WebSocket read returning {len(result)} bytes "
f"from buffer"
)
return result
else:
# We need more data, but we have some buffered
# Keep the buffered data and get more
logger.debug(
f"WebSocket read needs more data: have "
f"{len(self._read_buffer)}, need {n}"
)
pass
# If we need exactly n bytes but don't have enough, get more data
while n is not None and (
not self._read_buffer or len(self._read_buffer) < n
):
logger.debug(
f"WebSocket read getting more data: "
f"buffer_size={len(self._read_buffer)}, need={n}"
)
# Get the next WebSocket message and treat it as a byte stream
# This mimics the Go implementation's NextReader() approach
message = await self._ws_connection.get_message()
if isinstance(message, str):
message = message.encode("utf-8")
logger.debug(
f"WebSocket read received message: {len(message)} bytes"
)
# Add to buffer
self._read_buffer += message
# Return requested amount
if n is None: if n is None:
if not self._read_buffer:
try:
# Use a short timeout to avoid blocking indefinitely
with trio.fail_after(1.0): # 1 second timeout
message = await self._ws_connection.get_message()
if isinstance(message, str):
message = message.encode("utf-8")
self._read_buffer = message
except trio.TooSlowError:
# No message available within timeout
return b""
except Exception:
# Return empty bytes if no data available
# (connection closed)
return b""
result = self._read_buffer result = self._read_buffer
self._read_buffer = b"" self._read_buffer = b""
self._bytes_read += len(result) self._bytes_read += len(result)
logger.debug(
f"WebSocket read returning all data: {len(result)} bytes"
)
return result return result
else:
if len(self._read_buffer) >= n: # For specific byte count requests, return UP TO n bytes (not exactly n)
result = self._read_buffer[:n] # This matches TCP semantics where read(1024) returns available data
self._read_buffer = self._read_buffer[n:] # up to 1024 bytes
self._bytes_read += len(result)
logger.debug( # If we don't have any data buffered, try to get at least one message
f"WebSocket read returning exact {len(result)} bytes" if not self._read_buffer:
) try:
return result # Use a short timeout to avoid blocking indefinitely
else: with trio.fail_after(1.0): # 1 second timeout
# This should never happen due to the while loop above message = await self._ws_connection.get_message()
result = self._read_buffer if isinstance(message, str):
self._read_buffer = b"" message = message.encode("utf-8")
self._bytes_read += len(result) self._read_buffer = message
logger.debug( except trio.TooSlowError:
f"WebSocket read returning remaining {len(result)} bytes" return b"" # No data available
) except Exception:
return result return b""
# Now return up to n bytes from the buffer (TCP-like semantics)
if len(self._read_buffer) == 0:
return b""
# Return up to n bytes (like TCP read())
result = self._read_buffer[:n]
self._read_buffer = self._read_buffer[len(result) :]
self._bytes_read += len(result)
return result
except Exception as e: except Exception as e:
logger.error(f"WebSocket read failed: {e}") logger.error(f"WebSocket read failed: {e}")
@ -148,17 +121,18 @@ class P2PWebSocketConnection(ReadWriteCloser):
if self._closed: if self._closed:
return # Already closed return # Already closed
logger.debug("WebSocket connection closing")
try: try:
# Close the WebSocket connection # Always close the connection directly, avoid context manager issues
# The context manager may be causing cancel scope corruption
logger.debug("WebSocket closing connection directly")
await self._ws_connection.aclose() await self._ws_connection.aclose()
# Exit the context manager if we have one
if self._ws_context is not None:
await self._ws_context.__aexit__(None, None, None)
except Exception as e: except Exception as e:
logger.error(f"WebSocket close error: {e}") logger.error(f"WebSocket close error: {e}")
# Don't raise here, as close() should be idempotent # Don't raise here, as close() should be idempotent
finally: finally:
self._closed = True self._closed = True
logger.debug("WebSocket connection closed")
def conn_state(self) -> dict[str, Any]: def conn_state(self) -> dict[str, Any]:
""" """

21
libp2p/transport/websocket/listener.py
View File

@ -38,6 +38,7 @@ class WebsocketListener(IListener):
self._shutdown_event = trio.Event() self._shutdown_event = trio.Event()
self._nursery: trio.Nursery | None = None self._nursery: trio.Nursery | None = None
self._listeners: Any = None self._listeners: Any = None
self._is_wss = False # Track whether this is a WSS listener
async def listen(self, maddr: Multiaddr, nursery: trio.Nursery) -> bool: async def listen(self, maddr: Multiaddr, nursery: trio.Nursery) -> bool:
logger.debug(f"WebsocketListener.listen called with {maddr}") logger.debug(f"WebsocketListener.listen called with {maddr}")
@ -54,6 +55,9 @@ class WebsocketListener(IListener):
f"Cannot listen on WSS address {maddr} without TLS configuration" f"Cannot listen on WSS address {maddr} without TLS configuration"
) )
# Store whether this is a WSS listener
self._is_wss = parsed.is_wss
# Extract host and port from the base multiaddr # Extract host and port from the base multiaddr
host = ( host = (
parsed.rest_multiaddr.value_for_protocol("ip4") parsed.rest_multiaddr.value_for_protocol("ip4")
@ -169,16 +173,16 @@ class WebsocketListener(IListener):
if hasattr(self._listeners, "port"): if hasattr(self._listeners, "port"):
# This is a WebSocketServer object # This is a WebSocketServer object
port = self._listeners.port port = self._listeners.port
# Create a multiaddr from the port # Create a multiaddr from the port with correct WSS/WS protocol
# Note: We don't know if this is WS or WSS from the server object protocol = "wss" if self._is_wss else "ws"
# For now, assume WS - this could be improved by storing the original multiaddr return (Multiaddr(f"/ip4/127.0.0.1/tcp/{port}/{protocol}"),)
return (Multiaddr(f"/ip4/127.0.0.1/tcp/{port}/ws"),)
else: else:
# This is a list of listeners (like TCP) # This is a list of listeners (like TCP)
listeners = self._listeners listeners = self._listeners
# Get addresses from listeners like TCP does # Get addresses from listeners like TCP does
return tuple( return tuple(
_multiaddr_from_socket(listener.socket) for listener in listeners _multiaddr_from_socket(listener.socket, self._is_wss)
for listener in listeners
) )
async def close(self) -> None: async def close(self) -> None:
@ -212,7 +216,10 @@ class WebsocketListener(IListener):
logger.debug("WebsocketListener.close completed") logger.debug("WebsocketListener.close completed")
def _multiaddr_from_socket(socket: trio.socket.SocketType) -> Multiaddr: def _multiaddr_from_socket(
socket: trio.socket.SocketType, is_wss: bool = False
) -> Multiaddr:
"""Convert socket to multiaddr""" """Convert socket to multiaddr"""
ip, port = socket.getsockname() ip, port = socket.getsockname()
return Multiaddr(f"/ip4/{ip}/tcp/{port}/ws") protocol = "wss" if is_wss else "ws"
return Multiaddr(f"/ip4/{ip}/tcp/{port}/{protocol}")

4
libp2p/transport/websocket/multiaddr_utils.py
View File

@ -125,7 +125,7 @@ def is_valid_websocket_multiaddr(maddr: Multiaddr) -> bool:
# Find the WebSocket protocol # Find the WebSocket protocol
ws_protocol_found = False ws_protocol_found = False
tls_found = False tls_found = False
sni_found = False # sni_found = False # Not used currently
for i, protocol in enumerate(protocols[2:], start=2): for i, protocol in enumerate(protocols[2:], start=2):
if protocol.name in ws_protocols: if protocol.name in ws_protocols:
@ -134,7 +134,7 @@ def is_valid_websocket_multiaddr(maddr: Multiaddr) -> bool:
elif protocol.name in tls_protocols: elif protocol.name in tls_protocols:
tls_found = True tls_found = True
elif protocol.name in sni_protocols: elif protocol.name in sni_protocols:
# sni_found = True # Not used in current implementation pass # sni_found = True # Not used in current implementation
if not ws_protocol_found: if not ws_protocol_found:
return False return False

66
libp2p/transport/websocket/transport.py
View File

@ -2,7 +2,6 @@ import logging
import ssl import ssl
from multiaddr import Multiaddr from multiaddr import Multiaddr
import trio
from libp2p.abc import IListener, ITransport from libp2p.abc import IListener, ITransport
from libp2p.custom_types import THandler from libp2p.custom_types import THandler
@ -68,8 +67,6 @@ class WebsocketTransport(ITransport):
) )
try: try:
from trio_websocket import open_websocket_url
# Prepare SSL context for WSS connections # Prepare SSL context for WSS connections
ssl_context = None ssl_context = None
if parsed.is_wss: if parsed.is_wss:
@ -83,19 +80,63 @@ class WebsocketTransport(ITransport):
ssl_context.check_hostname = False ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE ssl_context.verify_mode = ssl.CERT_NONE
# Use the context manager but don't exit it immediately logger.debug(f"WebsocketTransport.dial opening connection to {ws_url}")
# The connection will be closed when the RawConnection is closed
ws_context = open_websocket_url(ws_url, ssl_context=ssl_context)
# Apply handshake timeout # Use a different approach: start background nursery that will persist
logger.debug("WebsocketTransport.dial establishing connection")
# Import trio-websocket functions
from trio_websocket import connect_websocket
from trio_websocket._impl import _url_to_host
# Parse the WebSocket URL to get host, port, resource
# like trio-websocket does
ws_host, ws_port, ws_resource, ws_ssl_context = _url_to_host(
ws_url, ssl_context
)
logger.debug(
f"WebsocketTransport.dial parsed URL: host={ws_host}, "
f"port={ws_port}, resource={ws_resource}"
)
# Instead of fighting trio-websocket's lifecycle, let's try using
# a persistent task that will keep the WebSocket alive
# This mimics what trio-websocket does internally but with our control
# Create a background task manager for this connection
import trio
nursery_manager = trio.lowlevel.current_task().parent_nursery
if nursery_manager is None:
raise OpenConnectionError(
f"No parent nursery available for WebSocket connection to {maddr}"
)
# Apply timeout to the connection process
with trio.fail_after(self._handshake_timeout): with trio.fail_after(self._handshake_timeout):
ws = await ws_context.__aenter__() logger.debug("WebsocketTransport.dial connecting WebSocket")
ws = await connect_websocket(
nursery_manager, # Use the existing nursery from libp2p
ws_host,
ws_port,
ws_resource,
use_ssl=ws_ssl_context,
message_queue_size=1024, # Reasonable defaults
max_message_size=16 * 1024 * 1024, # 16MB max message
)
logger.debug("WebsocketTransport.dial WebSocket connection established")
conn = P2PWebSocketConnection(ws, ws_context, is_secure=parsed.is_wss) # type: ignore[attr-defined] # Create our connection wrapper
return RawConnection(conn, initiator=True) # Pass None for nursery since we're using the parent nursery
conn = P2PWebSocketConnection(ws, None, is_secure=parsed.is_wss)
logger.debug("WebsocketTransport.dial created P2PWebSocketConnection")
return RawConnection(conn, initiator=True)
except trio.TooSlowError as e: except trio.TooSlowError as e:
raise OpenConnectionError( raise OpenConnectionError(
f"WebSocket handshake timeout after {self._handshake_timeout}s for {maddr}" f"WebSocket handshake timeout after {self._handshake_timeout}s "
f"for {maddr}"
) from e ) from e
except Exception as e: except Exception as e:
raise OpenConnectionError(f"Failed to dial WebSocket {maddr}: {e}") from e raise OpenConnectionError(f"Failed to dial WebSocket {maddr}: {e}") from e
@ -149,7 +190,8 @@ class WebsocketTransport(ITransport):
return [maddr] return [maddr]
# Create new multiaddr with SNI # Create new multiaddr with SNI
# For /dns/example.com/tcp/8080/wss -> /dns/example.com/tcp/8080/tls/sni/example.com/ws # For /dns/example.com/tcp/8080/wss ->
# /dns/example.com/tcp/8080/tls/sni/example.com/ws
try: try:
# Remove /wss and add /tls/sni/example.com/ws # Remove /wss and add /tls/sni/example.com/ws
without_wss = maddr.decapsulate(Multiaddr("/wss")) without_wss = maddr.decapsulate(Multiaddr("/wss"))

243
test_websocket_client.py
View File

@ -1,243 +0,0 @@
#!/usr/bin/env python3
"""
Standalone WebSocket client for testing py-libp2p WebSocket transport.
This script allows you to test the Python WebSocket client independently.
"""
import argparse
import logging
import sys
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.network.exceptions import SwarmException
from libp2p.peer.id import ID
from libp2p.peer.peerinfo import info_from_p2p_addr
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,
)
# Configure logging
logging.basicConfig(
level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
# Enable debug logging for WebSocket transport
logging.getLogger("libp2p.transport.websocket").setLevel(logging.DEBUG)
logging.getLogger("libp2p.network.swarm").setLevel(logging.DEBUG)
PING_PROTOCOL_ID = TProtocol("/ipfs/ping/1.0.0")
async def test_websocket_connection(destination: str, timeout: int = 30) -> bool:
"""
Test WebSocket connection to a destination multiaddr.
Args:
destination: Multiaddr string (e.g., /ip4/127.0.0.1/tcp/8080/ws/p2p/...)
timeout: Connection timeout in seconds
Returns:
True if connection successful, False otherwise
"""
try:
# Parse the destination multiaddr
maddr = Multiaddr(destination)
logger.info(f"Testing connection to: {maddr}")
# Validate WebSocket multiaddr
if not is_valid_websocket_multiaddr(maddr):
logger.error(f"Invalid WebSocket multiaddr: {maddr}")
return False
# Parse WebSocket multiaddr
try:
parsed = parse_websocket_multiaddr(maddr)
logger.info(
f"Parsed WebSocket multiaddr: is_wss={parsed.is_wss}, sni={parsed.sni}, rest_multiaddr={parsed.rest_multiaddr}"
)
except Exception as e:
logger.error(f"Failed to parse WebSocket multiaddr: {e}")
return False
# Extract peer ID from multiaddr
try:
peer_id = ID.from_base58(maddr.value_for_protocol("p2p"))
logger.info(f"Target peer ID: {peer_id}")
except Exception as e:
logger.error(f"Failed to extract peer ID from multiaddr: {e}")
return False
# Create Python host using professional pattern
logger.info("Creating Python host...")
key_pair = create_new_key_pair()
py_peer_id = ID.from_pubkey(key_pair.public_key)
logger.info(f"Python Peer ID: {py_peer_id}")
# Generate X25519 keypair for Noise
noise_key_pair = create_new_x25519_key_pair()
# Create security options (following professional pattern)
security_options = {
NOISE_PROTOCOL_ID: NoiseTransport(
libp2p_keypair=key_pair,
noise_privkey=noise_key_pair.private_key,
early_data=None,
with_noise_pipes=False,
)
}
# Create muxer options
muxer_options = create_yamux_muxer_option()
# Create host with proper configuration
host = new_host(
key_pair=key_pair,
sec_opt=security_options,
muxer_opt=muxer_options,
listen_addrs=[
Multiaddr("/ip4/0.0.0.0/tcp/0/ws")
], # WebSocket listen address
)
logger.info(f"Python host created: {host}")
# Create peer info using professional helper
peer_info = info_from_p2p_addr(maddr)
logger.info(f"Connecting to: {peer_info}")
# Start the host
logger.info("Starting host...")
async with host.run(listen_addrs=[]):
# Wait a moment for host to be ready
await trio.sleep(1)
# Attempt connection with timeout
logger.info("Attempting to connect...")
try:
with trio.fail_after(timeout):
await host.connect(peer_info)
logger.info("✅ Successfully connected to peer!")
# Test ping protocol (following professional pattern)
logger.info("Testing ping protocol...")
try:
stream = await host.new_stream(
peer_info.peer_id, [PING_PROTOCOL_ID]
)
logger.info("✅ Successfully created ping stream!")
# Send ping (32 bytes as per libp2p ping protocol)
ping_data = b"\x01" * 32
await stream.write(ping_data)
logger.info(f"✅ Sent ping: {len(ping_data)} bytes")
# Wait for pong (should be same 32 bytes)
pong_data = await stream.read(32)
logger.info(f"✅ Received pong: {len(pong_data)} bytes")
if pong_data == ping_data:
logger.info("✅ Ping-pong test successful!")
return True
else:
logger.error(
f"❌ Unexpected pong data: expected {len(ping_data)} bytes, got {len(pong_data)} bytes"
)
return False
except Exception as e:
logger.error(f"❌ Ping protocol test failed: {e}")
return False
except trio.TooSlowError:
logger.error(f"❌ Connection timeout after {timeout} seconds")
return False
except SwarmException as e:
logger.error(f"❌ Connection failed with SwarmException: {e}")
# Log the underlying error details
if hasattr(e, "__cause__") and e.__cause__:
logger.error(f"Underlying error: {e.__cause__}")
return False
except Exception as e:
logger.error(f"❌ Connection failed with unexpected error: {e}")
import traceback
logger.error(f"Full traceback: {traceback.format_exc()}")
return False
except Exception as e:
logger.error(f"❌ Test failed with error: {e}")
return False
async def main():
"""Main function to run the WebSocket client test."""
parser = argparse.ArgumentParser(
description="Test py-libp2p WebSocket client connection",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Test connection to a WebSocket peer
python test_websocket_client.py /ip4/127.0.0.1/tcp/8080/ws/p2p/12D3KooW...
# Test with custom timeout
python test_websocket_client.py /ip4/127.0.0.1/tcp/8080/ws/p2p/12D3KooW... --timeout 60
# Test WSS connection
python test_websocket_client.py /ip4/127.0.0.1/tcp/8080/wss/p2p/12D3KooW...
""",
)
parser.add_argument(
"destination",
help="Destination multiaddr (e.g., /ip4/127.0.0.1/tcp/8080/ws/p2p/12D3KooW...)",
)
parser.add_argument(
"--timeout",
type=int,
default=30,
help="Connection timeout in seconds (default: 30)",
)
parser.add_argument(
"--verbose", "-v", action="store_true", help="Enable verbose logging"
)
args = parser.parse_args()
# Set logging level
if args.verbose:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
logger.info("🚀 Starting WebSocket client test...")
logger.info(f"Destination: {args.destination}")
logger.info(f"Timeout: {args.timeout}s")
# Run the test
success = await test_websocket_connection(args.destination, args.timeout)
if success:
logger.info("🎉 WebSocket client test completed successfully!")
sys.exit(0)
else:
logger.error("💥 WebSocket client test failed!")
sys.exit(1)
if __name__ == "__main__":
# Run with trio
trio.run(main)

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

@ -3,6 +3,7 @@ import logging
from typing import Any from typing import Any
import pytest import pytest
from exceptiongroup import ExceptionGroup
from multiaddr import Multiaddr from multiaddr import Multiaddr
import trio import trio
@ -623,6 +624,7 @@ async def test_websocket_data_exchange():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # WebSocket transport
) )
# Test data # Test data
@ -675,7 +677,10 @@ async def test_websocket_data_exchange():
@pytest.mark.trio @pytest.mark.trio
async def test_websocket_host_pair_data_exchange(): async def test_websocket_host_pair_data_exchange():
"""Test WebSocket host pair with actual data exchange using host_pair_factory pattern""" """
Test WebSocket host pair with actual data exchange using host_pair_factory
pattern.
"""
from libp2p import create_yamux_muxer_option, new_host from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol from libp2p.custom_types import TProtocol
@ -712,6 +717,7 @@ async def test_websocket_host_pair_data_exchange():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # WebSocket transport
) )
# Test data # Test data
@ -784,16 +790,102 @@ async def test_wss_host_pair_data_exchange():
InsecureTransport, InsecureTransport,
) )
# Create TLS context for WSS # Create TLS contexts for WSS (separate for client and server)
tls_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) # For testing, we need to create a self-signed certificate
tls_context.check_hostname = False try:
tls_context.verify_mode = ssl.CERT_NONE import datetime
import ipaddress
import os
import tempfile
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID
# Generate private key
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
)
# Create certificate
subject = issuer = x509.Name(
[
x509.NameAttribute(NameOID.COUNTRY_NAME, "US"), # type: ignore
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Test"), # type: ignore
x509.NameAttribute(NameOID.LOCALITY_NAME, "Test"), # type: ignore
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Test"), # type: ignore
x509.NameAttribute(NameOID.COMMON_NAME, "localhost"), # type: ignore
]
)
cert = (
x509.CertificateBuilder()
.subject_name(subject)
.issuer_name(issuer)
.public_key(private_key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(datetime.datetime.now(datetime.UTC))
.not_valid_after(
datetime.datetime.now(datetime.UTC) + datetime.timedelta(days=1)
)
.add_extension(
x509.SubjectAlternativeName(
[
x509.DNSName("localhost"),
x509.IPAddress(ipaddress.IPv4Address("127.0.0.1")),
]
),
critical=False,
)
.sign(private_key, hashes.SHA256())
)
# Create temporary files for cert and key
cert_file = tempfile.NamedTemporaryFile(mode="wb", delete=False, suffix=".crt")
key_file = tempfile.NamedTemporaryFile(mode="wb", delete=False, suffix=".key")
# Write certificate and key to files
cert_file.write(cert.public_bytes(serialization.Encoding.PEM))
key_file.write(
private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption(),
)
)
cert_file.close()
key_file.close()
# Server context for listener (Host A)
server_tls_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
server_tls_context.load_cert_chain(cert_file.name, key_file.name)
# Client context for dialer (Host B)
client_tls_context = ssl.create_default_context()
client_tls_context.check_hostname = False
client_tls_context.verify_mode = ssl.CERT_NONE
# Clean up temp files after use
def cleanup_certs():
try:
os.unlink(cert_file.name)
os.unlink(key_file.name)
except Exception:
pass
except ImportError:
pytest.skip("cryptography package required for WSS tests")
except Exception as e:
pytest.skip(f"Failed to create test certificates: {e}")
# Create two hosts with WSS transport and plaintext security # Create two hosts with WSS transport and plaintext security
key_pair_a = create_new_key_pair() key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair() key_pair_b = create_new_key_pair()
# Host A (listener) - WSS transport # Host A (listener) - WSS transport with server TLS config
security_options_a = { security_options_a = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport( PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None local_key_pair=key_pair_a, secure_bytes_provider=None, peerstore=None
@ -804,9 +896,10 @@ async def test_wss_host_pair_data_exchange():
sec_opt=security_options_a, sec_opt=security_options_a,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/wss")], listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/wss")],
tls_server_config=server_tls_context,
) )
# Host B (dialer) - WSS transport # Host B (dialer) - WSS transport with client TLS config
security_options_b = { security_options_b = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport( PLAINTEXT_PROTOCOL_ID: InsecureTransport(
local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None local_key_pair=key_pair_b, secure_bytes_provider=None, peerstore=None
@ -816,6 +909,8 @@ async def test_wss_host_pair_data_exchange():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/wss")], # Ensure WSS transport
tls_client_config=client_tls_context,
) )
# Test data # Test data
@ -1028,7 +1123,7 @@ async def test_wss_transport_without_tls_config():
@pytest.mark.trio @pytest.mark.trio
async def test_wss_dial_parsing(): async def test_wss_dial_parsing():
"""Test WSS dial functionality with multiaddr parsing.""" """Test WSS dial functionality with multiaddr parsing."""
upgrader = create_upgrader() # upgrader = create_upgrader() # Not used in this test
# transport = WebsocketTransport(upgrader) # Not used in this test # transport = WebsocketTransport(upgrader) # Not used in this test
# Test WSS multiaddr parsing in dial # Test WSS multiaddr parsing in dial
@ -1085,10 +1180,15 @@ async def test_wss_listen_without_tls_config():
listener = transport.create_listener(dummy_handler) listener = transport.create_listener(dummy_handler)
# This should raise an error when trying to listen on WSS without TLS config # This should raise an error when trying to listen on WSS without TLS config
with pytest.raises( with pytest.raises(ExceptionGroup) as exc_info:
ValueError, match="Cannot listen on WSS address.*without TLS configuration" async with trio.open_nursery() as nursery:
): await listener.listen(wss_maddr, nursery)
await listener.listen(wss_maddr, trio.open_nursery())
# Check that the ExceptionGroup contains the expected ValueError
assert len(exc_info.value.exceptions) == 1
assert isinstance(exc_info.value.exceptions[0], ValueError)
assert "Cannot listen on WSS address" in str(exc_info.value.exceptions[0])
assert "without TLS configuration" in str(exc_info.value.exceptions[0])
@pytest.mark.trio @pytest.mark.trio
@ -1213,7 +1313,7 @@ def test_wss_vs_ws_distinction():
@pytest.mark.trio @pytest.mark.trio
async def test_wss_connection_handling(): async def test_wss_connection_handling():
"""Test WSS connection handling with security flag.""" """Test WSS connection handling with security flag."""
upgrader = create_upgrader() # upgrader = create_upgrader() # Not used in this test
# transport = WebsocketTransport(upgrader) # Not used in this test # transport = WebsocketTransport(upgrader) # Not used in this test
# Test that WSS connections are marked as secure # Test that WSS connections are marked as secure
@ -1263,7 +1363,9 @@ async def test_handshake_timeout():
await trio.sleep(0) await trio.sleep(0)
listener = transport.create_listener(dummy_handler) listener = transport.create_listener(dummy_handler)
assert listener._handshake_timeout == 0.1 # Type assertion to access private attribute for testing
assert hasattr(listener, "_handshake_timeout")
assert getattr(listener, "_handshake_timeout") == 0.1
@pytest.mark.trio @pytest.mark.trio
@ -1275,11 +1377,14 @@ async def test_handshake_timeout_creation():
from libp2p.transport import create_transport from libp2p.transport import create_transport
transport = create_transport("ws", upgrader, handshake_timeout=5.0) transport = create_transport("ws", upgrader, handshake_timeout=5.0)
assert transport._handshake_timeout == 5.0 # Type assertion to access private attribute for testing
assert hasattr(transport, "_handshake_timeout")
assert getattr(transport, "_handshake_timeout") == 5.0
# Test default timeout # Test default timeout
transport_default = create_transport("ws", upgrader) transport_default = create_transport("ws", upgrader)
assert transport_default._handshake_timeout == 15.0 assert hasattr(transport_default, "_handshake_timeout")
assert getattr(transport_default, "_handshake_timeout") == 15.0
@pytest.mark.trio @pytest.mark.trio
@ -1310,7 +1415,8 @@ async def test_connection_state_tracking():
assert state["total_bytes"] == 0 assert state["total_bytes"] == 0
assert state["connection_duration"] >= 0 assert state["connection_duration"] >= 0
# Test byte tracking (we can't actually read/write with mock, but we can test the method) # 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 # The actual byte tracking will be tested in integration tests
assert hasattr(conn, "_bytes_read") assert hasattr(conn, "_bytes_read")
assert hasattr(conn, "_bytes_written") assert hasattr(conn, "_bytes_written")
@ -1396,7 +1502,7 @@ async def test_zero_byte_write_handling():
@pytest.mark.trio @pytest.mark.trio
async def test_websocket_transport_protocols(): async def test_websocket_transport_protocols():
"""Test that WebSocket transport reports correct protocols.""" """Test that WebSocket transport reports correct protocols."""
upgrader = create_upgrader() # upgrader = create_upgrader() # Not used in this test
# transport = WebsocketTransport(upgrader) # Not used in this test # transport = WebsocketTransport(upgrader) # Not used in this test
# Test that the transport can handle both WS and WSS protocols # Test that the transport can handle both WS and WSS protocols
@ -1427,7 +1533,9 @@ async def test_websocket_listener_addr_format():
await trio.sleep(0) await trio.sleep(0)
listener_ws = transport_ws.create_listener(dummy_handler_ws) listener_ws = transport_ws.create_listener(dummy_handler_ws)
assert listener_ws._handshake_timeout == 15.0 # Default timeout # Type assertion to access private attribute for testing
assert hasattr(listener_ws, "_handshake_timeout")
assert getattr(listener_ws, "_handshake_timeout") == 15.0 # Default timeout
# Test WSS listener with TLS config # Test WSS listener with TLS config
import ssl import ssl
@ -1439,13 +1547,19 @@ async def test_websocket_listener_addr_format():
await trio.sleep(0) await trio.sleep(0)
listener_wss = transport_wss.create_listener(dummy_handler_wss) listener_wss = transport_wss.create_listener(dummy_handler_wss)
assert listener_wss._tls_config is not None # Type assertion to access private attributes for testing
assert listener_wss._handshake_timeout == 15.0 assert hasattr(listener_wss, "_tls_config")
assert getattr(listener_wss, "_tls_config") is not None
assert hasattr(listener_wss, "_handshake_timeout")
assert getattr(listener_wss, "_handshake_timeout") == 15.0
@pytest.mark.trio @pytest.mark.trio
async def test_sni_resolution_limitation(): async def test_sni_resolution_limitation():
"""Test SNI resolution limitation - Python multiaddr library doesn't support SNI protocol.""" """
Test SNI resolution limitation - Python multiaddr library doesn't support
SNI protocol.
"""
upgrader = create_upgrader() upgrader = create_upgrader()
transport = WebsocketTransport(upgrader) transport = WebsocketTransport(upgrader)
@ -1471,7 +1585,7 @@ async def test_sni_resolution_limitation():
@pytest.mark.trio @pytest.mark.trio
async def test_websocket_transport_can_dial(): async def test_websocket_transport_can_dial():
"""Test WebSocket transport CanDial functionality similar to Go implementation.""" """Test WebSocket transport CanDial functionality similar to Go implementation."""
upgrader = create_upgrader() # upgrader = create_upgrader() # Not used in this test
# transport = WebsocketTransport(upgrader) # Not used in this test # transport = WebsocketTransport(upgrader) # Not used in this test
# Test valid WebSocket addresses that should be dialable # Test valid WebSocket addresses that should be dialable

32
tests/core/transport/test_websocket_p2p.py
View File

@ -8,7 +8,6 @@ including both WS and WSS (WebSocket Secure) scenarios.
import pytest import pytest
from multiaddr import Multiaddr from multiaddr import Multiaddr
import trio
from libp2p import create_yamux_muxer_option, new_host from libp2p import create_yamux_muxer_option, new_host
from libp2p.crypto.secp256k1 import create_new_key_pair from libp2p.crypto.secp256k1 import create_new_key_pair
@ -58,6 +57,8 @@ async def test_websocket_p2p_plaintext():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # Ensure WebSocket
# transport
) )
# Test data # Test data
@ -152,6 +153,8 @@ async def test_websocket_p2p_noise():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # Ensure WebSocket
# transport
) )
# Test data # Test data
@ -246,6 +249,8 @@ async def test_websocket_p2p_libp2p_ping():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # Ensure WebSocket
# transport
) )
# Set up ping handler on host A (standard libp2p ping protocol) # Set up ping handler on host A (standard libp2p ping protocol)
@ -301,7 +306,10 @@ async def test_websocket_p2p_libp2p_ping():
@pytest.mark.trio @pytest.mark.trio
async def test_websocket_p2p_multiple_streams(): async def test_websocket_p2p_multiple_streams():
"""Test Python-to-Python WebSocket communication with multiple concurrent streams.""" """
Test Python-to-Python WebSocket communication with multiple concurrent
streams.
"""
# Create two hosts with Noise security # Create two hosts with Noise security
key_pair_a = create_new_key_pair() key_pair_a = create_new_key_pair()
key_pair_b = create_new_key_pair() key_pair_b = create_new_key_pair()
@ -337,6 +345,8 @@ async def test_websocket_p2p_multiple_streams():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # Ensure WebSocket
# transport
) )
# Test protocol # Test protocol
@ -385,7 +395,9 @@ async def test_websocket_p2p_multiple_streams():
return response return response
# Run all streams concurrently # Run all streams concurrently
tasks = [create_stream_and_test(i, test_data_list[i]) for i in range(num_streams)] tasks = [
create_stream_and_test(i, test_data_list[i]) for i in range(num_streams)
]
responses = [] responses = []
for task in tasks: for task in tasks:
responses.append(await task) responses.append(await task)
@ -439,6 +451,8 @@ async def test_websocket_p2p_connection_state():
key_pair=key_pair_b, key_pair=key_pair_b,
sec_opt=security_options_b, sec_opt=security_options_b,
muxer_opt=create_yamux_muxer_option(), muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")], # Ensure WebSocket
# transport
) )
# Set up handler on host A # Set up handler on host A
@ -488,21 +502,23 @@ async def test_websocket_p2p_connection_state():
# Get the connection to host A # Get the connection to host A
conn_to_a = None conn_to_a = None
for peer_id, conn in connections.items(): for peer_id, conn_list in connections.items():
if peer_id == host_a.get_id(): if peer_id == host_a.get_id():
conn_to_a = conn # connections maps peer_id to list of connections, get the first one
conn_to_a = conn_list[0] if conn_list else None
break break
assert conn_to_a is not None, "Should have connection to host A" assert conn_to_a is not None, "Should have connection to host A"
# Test that the connection has the expected properties # 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"), "Connection should have muxed_conn"
assert hasattr(conn_to_a.muxed_conn, "conn"), ( assert hasattr(conn_to_a.muxed_conn, "secured_conn"), (
"Muxed connection should have underlying conn" "Muxed connection should have underlying secured_conn"
) )
# If the underlying connection is our WebSocket connection, test its state # If the underlying connection is our WebSocket connection, test its state
underlying_conn = conn_to_a.muxed_conn.conn # Type assertion to access private attribute for testing
underlying_conn = getattr(conn_to_a.muxed_conn, "secured_conn")
if hasattr(underlying_conn, "conn_state"): if hasattr(underlying_conn, "conn_state"):
state = underlying_conn.conn_state() state = underlying_conn.conn_state()
assert "connection_start_time" in state, ( assert "connection_start_time" in state, (

2
tests/interop/js_libp2p/js_node/src/package.json
View File

@ -13,7 +13,9 @@
"@libp2p/ping": "^2.0.36", "@libp2p/ping": "^2.0.36",
"@libp2p/websockets": "^9.2.18", "@libp2p/websockets": "^9.2.18",
"@chainsafe/libp2p-yamux": "^5.0.1", "@chainsafe/libp2p-yamux": "^5.0.1",
"@chainsafe/libp2p-noise": "^16.0.1",
"@libp2p/plaintext": "^2.0.7", "@libp2p/plaintext": "^2.0.7",
"@libp2p/identify": "^3.0.39",
"libp2p": "^2.9.0", "libp2p": "^2.9.0",
"multiaddr": "^10.0.1" "multiaddr": "^10.0.1"
} }

107
tests/interop/js_libp2p/js_node/src/ws_ping_node.mjs
View File

@ -1,22 +1,76 @@
import { createLibp2p } from 'libp2p' import { createLibp2p } from 'libp2p'
import { webSockets } from '@libp2p/websockets' import { webSockets } from '@libp2p/websockets'
import { ping } from '@libp2p/ping' import { ping } from '@libp2p/ping'
import { noise } from '@chainsafe/libp2p-noise'
import { plaintext } from '@libp2p/plaintext' import { plaintext } from '@libp2p/plaintext'
import { yamux } from '@chainsafe/libp2p-yamux' import { yamux } from '@chainsafe/libp2p-yamux'
// import { identify } from '@libp2p/identify' // Commented out for compatibility
// Configuration from environment (with defaults for compatibility)
const TRANSPORT = process.env.transport || 'ws'
const SECURITY = process.env.security || 'noise'
const MUXER = process.env.muxer || 'yamux'
const IP = process.env.ip || '0.0.0.0'
async function main() { async function main() {
const node = await createLibp2p({ console.log(`🔧 Configuration: transport=${TRANSPORT}, security=${SECURITY}, muxer=${MUXER}`)
transports: [ webSockets() ],
connectionEncryption: [ plaintext() ], // Build options following the proven pattern from test-plans-fork
streamMuxers: [ yamux() ], const options = {
services: { start: true,
// installs /ipfs/ping/1.0.0 handler connectionGater: {
ping: ping() denyDialMultiaddr: async () => false
}, },
addresses: { connectionMonitor: {
listen: ['/ip4/0.0.0.0/tcp/0/ws'] enabled: false
},
services: {
ping: ping()
} }
}) }
// Transport configuration (following get-libp2p.ts pattern)
switch (TRANSPORT) {
case 'ws':
options.transports = [webSockets()]
options.addresses = {
listen: [`/ip4/${IP}/tcp/0/ws`]
}
break
case 'wss':
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
options.transports = [webSockets()]
options.addresses = {
listen: [`/ip4/${IP}/tcp/0/wss`]
}
break
default:
throw new Error(`Unknown transport: ${TRANSPORT}`)
}
// Security configuration
switch (SECURITY) {
case 'noise':
options.connectionEncryption = [noise()]
break
case 'plaintext':
options.connectionEncryption = [plaintext()]
break
default:
throw new Error(`Unknown security: ${SECURITY}`)
}
// Muxer configuration
switch (MUXER) {
case 'yamux':
options.streamMuxers = [yamux()]
break
default:
throw new Error(`Unknown muxer: ${MUXER}`)
}
console.log('🔧 Creating libp2p node with proven interop configuration...')
const node = await createLibp2p(options)
await node.start() await node.start()
@ -25,6 +79,39 @@ async function main() {
console.log(addr.toString()) console.log(addr.toString())
} }
// Debug: Print supported protocols
console.log('DEBUG: Supported protocols:')
if (node.services && node.services.registrar) {
const protocols = node.services.registrar.getProtocols()
for (const protocol of protocols) {
console.log('DEBUG: Protocol:', protocol)
}
}
// Debug: Print connection encryption protocols
console.log('DEBUG: Connection encryption protocols:')
try {
if (node.components && node.components.connectionEncryption) {
for (const encrypter of node.components.connectionEncryption) {
console.log('DEBUG: Encrypter:', encrypter.protocol)
}
}
} catch (e) {
console.log('DEBUG: Could not access connectionEncryption:', e.message)
}
// Debug: Print stream muxer protocols
console.log('DEBUG: Stream muxer protocols:')
try {
if (node.components && node.components.streamMuxers) {
for (const muxer of node.components.streamMuxers) {
console.log('DEBUG: Muxer:', muxer.protocol)
}
}
} catch (e) {
console.log('DEBUG: Could not access streamMuxers:', e.message)
}
// Keep the process alive // Keep the process alive
await new Promise(() => {}) await new Promise(() => {})
} }

179
tests/interop/test_js_ws_ping.py
View File

@ -9,16 +9,8 @@ from trio.lowlevel import open_process
from libp2p.crypto.secp256k1 import create_new_key_pair from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol from libp2p.custom_types import TProtocol
from libp2p.host.basic_host import BasicHost
from libp2p.network.exceptions import SwarmException from libp2p.network.exceptions import SwarmException
from libp2p.network.swarm import Swarm
from libp2p.peer.id import ID from libp2p.peer.id import ID
from libp2p.peer.peerinfo import PeerInfo
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.transport import WebsocketTransport
PLAINTEXT_PROTOCOL_ID = "/plaintext/2.0.0" PLAINTEXT_PROTOCOL_ID = "/plaintext/2.0.0"
@ -97,11 +89,14 @@ async def test_ping_with_js_node():
stderr = proc.stderr stderr = proc.stderr
try: try:
# Read first two lines (PeerID and multiaddr) # Read JS node output until we get peer ID and multiaddrs
print("Waiting for JS node to output PeerID and multiaddr...") print("Waiting for JS node to output PeerID and multiaddrs...")
buffer = b"" buffer = b""
peer_id_found: str | bool = False
multiaddrs_found = []
with trio.fail_after(30): with trio.fail_after(30):
while buffer.count(b"\n") < 2: while True:
chunk = await stdout.receive_some(1024) chunk = await stdout.receive_some(1024)
if not chunk: if not chunk:
print("No more data from JS node stdout") print("No more data from JS node stdout")
@ -109,53 +104,84 @@ async def test_ping_with_js_node():
buffer += chunk buffer += chunk
print(f"Received chunk: {chunk}") print(f"Received chunk: {chunk}")
print(f"Total buffer received: {buffer}") # Parse lines as we receive them
lines = [line for line in buffer.decode().splitlines() if line.strip()] lines = buffer.decode().splitlines()
print(f"Parsed lines: {lines}") for line in lines:
line = line.strip()
if not line:
continue
if len(lines) < 2: # Look for peer ID (starts with "12D3Koo")
print("Not enough lines from JS node, checking stderr...") if line.startswith("12D3Koo") and not peer_id_found:
peer_id_found = line
print(f"Found peer ID: {peer_id_found}")
# Look for multiaddrs (start with "/ip4/" or "/ip6/")
elif line.startswith("/ip4/") or line.startswith("/ip6/"):
if line not in multiaddrs_found:
multiaddrs_found.append(line)
print(f"Found multiaddr: {line}")
# Stop when we have peer ID and at least one multiaddr
if peer_id_found and multiaddrs_found:
print(f"✅ Collected: Peer ID + {len(multiaddrs_found)} multiaddrs")
break
print(f"Total buffer received: {buffer}")
all_lines = [line for line in buffer.decode().splitlines() if line.strip()]
print(f"All JS Node lines: {all_lines}")
if not peer_id_found or not multiaddrs_found:
print("Missing peer ID or multiaddrs from JS node, checking stderr...")
stderr_output = await stderr.receive_some(2048) stderr_output = await stderr.receive_some(2048)
stderr_output = stderr_output.decode() stderr_output = stderr_output.decode()
print(f"JS node stderr: {stderr_output}") print(f"JS node stderr: {stderr_output}")
pytest.fail( pytest.fail(
"JS node did not produce expected PeerID and multiaddr.\n" "JS node did not produce expected PeerID and multiaddr.\n"
f"Found peer ID: {peer_id_found}\n"
f"Found multiaddrs: {multiaddrs_found}\n"
f"Stdout: {buffer.decode()!r}\n" f"Stdout: {buffer.decode()!r}\n"
f"Stderr: {stderr_output!r}" f"Stderr: {stderr_output!r}"
) )
peer_id_line, addr_line = lines[0], lines[1]
peer_id = ID.from_base58(peer_id_line) # peer_id = ID.from_base58(peer_id_found) # Not used currently
maddr = Multiaddr(addr_line) # Use the first localhost multiaddr preferentially, or fallback to first
# available
maddr = None
for addr_str in multiaddrs_found:
if "127.0.0.1" in addr_str:
maddr = Multiaddr(addr_str)
break
if not maddr:
maddr = Multiaddr(multiaddrs_found[0])
# Debug: Print what we're trying to connect to # Debug: Print what we're trying to connect to
print(f"JS Node Peer ID: {peer_id_line}") print(f"JS Node Peer ID: {peer_id_found}")
print(f"JS Node Address: {addr_line}") print(f"JS Node Address: {maddr}")
print(f"All JS Node lines: {lines}") print(f"All found multiaddrs: {multiaddrs_found}")
print(f"Parsed multiaddr: {maddr}") print(f"Selected multiaddr: {maddr}")
# Set up Python host # Set up Python host using new_host API with Noise security
print("Setting up Python host...") print("Setting up Python host...")
key_pair = create_new_key_pair() from libp2p import create_yamux_muxer_option, new_host
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 key_pair = create_new_key_pair()
upgrader = TransportUpgrader( # noise_key_pair = create_new_x25519_key_pair() # Not used currently
secure_transports_by_protocol={ print(f"Python Peer ID: {ID.from_pubkey(key_pair.public_key)}")
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair)
}, # Use default security options (includes Noise, SecIO, and plaintext)
muxer_transports_by_protocol={TProtocol("/yamux/1.0.0"): Yamux}, # This will allow protocol negotiation to choose the best match
host = new_host(
key_pair=key_pair,
muxer_opt=create_yamux_muxer_option(),
listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0/ws")],
) )
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}") print(f"Python host created: {host}")
# Connect to JS node # Connect to JS node using modern peer info
peer_info = PeerInfo(peer_id, [maddr]) from libp2p.peer.peerinfo import info_from_p2p_addr
peer_info = info_from_p2p_addr(maddr)
print(f"Python trying to connect to: {peer_info}") print(f"Python trying to connect to: {peer_info}")
print(f"Peer info addresses: {peer_info.addrs}") print(f"Peer info addresses: {peer_info.addrs}")
@ -169,37 +195,62 @@ async def test_ping_with_js_node():
try: try:
parsed = parse_websocket_multiaddr(maddr) parsed = parse_websocket_multiaddr(maddr)
print( print(
f"Parsed WebSocket multiaddr: is_wss={parsed.is_wss}, sni={parsed.sni}, rest_multiaddr={parsed.rest_multiaddr}" f"Parsed WebSocket multiaddr: is_wss={parsed.is_wss}, "
f"sni={parsed.sni}, rest_multiaddr={parsed.rest_multiaddr}"
) )
except Exception as e: except Exception as e:
print(f"Failed to parse WebSocket multiaddr: {e}") print(f"Failed to parse WebSocket multiaddr: {e}")
await trio.sleep(1) # Use proper host.run() context manager
async with host.run(listen_addrs=[]):
await trio.sleep(1)
try: try:
print("Attempting to connect to JS node...") print("Attempting to connect to JS node...")
await host.connect(peer_info) await host.connect(peer_info)
print("Successfully connected to JS node!") print("Successfully connected to JS node!")
except SwarmException as e: except SwarmException as e:
underlying_error = e.__cause__ underlying_error = e.__cause__
print(f"Connection failed with SwarmException: {e}") print(f"Connection failed with SwarmException: {e}")
print(f"Underlying error: {underlying_error}") print(f"Underlying error: {underlying_error}")
pytest.fail( pytest.fail(
"Connection failed with SwarmException.\n" "Connection failed with SwarmException.\n"
f"THE REAL ERROR IS: {underlying_error!r}\n" f"THE REAL ERROR IS: {underlying_error!r}\n"
) )
assert host.get_network().connections.get(peer_id) is not None # Verify connection was established
assert host.get_network().connections.get(peer_info.peer_id) is not None
# Ping protocol # Try to ping the JS node
stream = await host.new_stream(peer_id, [TProtocol("/ipfs/ping/1.0.0")]) ping_protocol = TProtocol("/ipfs/ping/1.0.0")
await stream.write(b"ping") try:
data = await stream.read(4) print("Opening ping stream...")
assert data == b"pong" stream = await host.new_stream(peer_info.peer_id, [ping_protocol])
print("Ping stream opened successfully!")
print("Closing Python host...") # Send ping data (32 bytes as per libp2p ping protocol)
await host.close() ping_data = b"\x00" * 32
print("Python host closed successfully") await stream.write(ping_data)
print(f"Sent ping: {len(ping_data)} bytes")
# Wait for pong response
pong_data = await stream.read(32)
print(f"Received pong: {len(pong_data)} bytes")
# Verify the pong matches the ping
assert pong_data == ping_data, (
f"Ping/pong mismatch: {ping_data!r} != {pong_data!r}"
)
print("✅ Ping/pong successful!")
await stream.close()
print("Stream closed successfully!")
except Exception as e:
print(f"Ping failed: {e}")
pytest.fail(f"Ping failed: {e}")
print("🎉 JavaScript WebSocket interop test completed successfully!")
finally: finally:
print(f"Terminating JS node process (PID: {proc.pid})...") print(f"Terminating JS node process (PID: {proc.pid})...")
try: try: