libp2p 0.2.0__tar.gz → 0.2.1__tar.gz

{libp2p-0.2.0/libp2p.egg-info → libp2p-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libp2p
-Version: 0.2.0
+Version: 0.2.1
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation
@@ -38,7 +38,7 @@ Requires-Dist: pymultihash>=0.8.2
 Requires-Dist: pynacl>=1.3.0
 Requires-Dist: rpcudp>=3.0.0
 Requires-Dist: trio-typing>=0.0.4
-Requires-Dist: trio>=0.15.0
+Requires-Dist: trio>=0.26.0
 Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
 Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
 Provides-Extra: dev

libp2p-0.2.1/examples/ping/ping.py

@@ -0,0 +1,120 @@
+import argparse
+
+import multiaddr
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.network.stream.net_stream_interface import (
+    INetStream,
+)
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+from libp2p.typing import (
+    TProtocol,
+)
+
+PING_PROTOCOL_ID = TProtocol("/ipfs/ping/1.0.0")
+PING_LENGTH = 32
+RESP_TIMEOUT = 60
+
+
+async def handle_ping(stream: INetStream) -> None:
+    while True:
+        try:
+            payload = await stream.read(PING_LENGTH)
+            peer_id = stream.muxed_conn.peer_id
+            if payload is not None:
+                print(f"received ping from {peer_id}")
+
+                await stream.write(payload)
+                print(f"responded with pong to {peer_id}")
+
+        except Exception:
+            await stream.reset()
+
+
+async def send_ping(stream: INetStream) -> None:
+    try:
+        payload = b"\x01" * PING_LENGTH
+        print(f"sending ping to {stream.muxed_conn.peer_id}")
+
+        await stream.write(payload)
+
+        with trio.fail_after(RESP_TIMEOUT):
+            response = await stream.read(PING_LENGTH)
+
+        if response == payload:
+            print(f"received pong from {stream.muxed_conn.peer_id}")
+
+    except Exception as e:
+        print(f"error occurred : {e}")
+
+
+async def run(port: int, destination: str) -> None:
+    localhost_ip = "127.0.0.1"
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+    host = new_host()
+
+    async with host.run(listen_addrs=[listen_addr]), trio.open_nursery() as nursery:
+        if not destination:
+            host.set_stream_handler(PING_PROTOCOL_ID, handle_ping)
+
+            print(
+                "Run this from the same folder in another console:\n\n"
+                f"python ping.py -p {int(port) + 1} "
+                f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
+            )
+            print("Waiting for incoming connection...")
+
+        else:
+            maddr = multiaddr.Multiaddr(destination)
+            info = info_from_p2p_addr(maddr)
+            await host.connect(info)
+            stream = await host.new_stream(info.peer_id, [PING_PROTOCOL_ID])
+
+            nursery.start_soon(send_ping, stream)
+
+            return
+
+        await trio.sleep_forever()
+
+
+def main() -> None:
+    description = """
+    This program demonstrates a simple p2p ping application using libp2p.
+    To use it, first run 'python ping.py -p <PORT>', where <PORT> is the port number.
+    Then, run another instance with 'python ping.py -p <ANOTHER_PORT> -d <DESTINATION>',
+    where <DESTINATION> is the multiaddress of the previous listener host.
+    """
+
+    example_maddr = (
+        "/ip4/127.0.0.1/tcp/8000/p2p/QmQn4SwGkDZKkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
+    )
+
+    parser = argparse.ArgumentParser(description=description)
+
+    parser.add_argument(
+        "-p", "--port", default=8000, type=int, help="source port number"
+    )
+    parser.add_argument(
+        "-d",
+        "--destination",
+        type=str,
+        help=f"destination multiaddr string, e.g. {example_maddr}",
+    )
+    args = parser.parse_args()
+
+    if not args.port:
+        raise RuntimeError("failed to determine local port")
+
+    try:
+        trio.run(run, *(args.port, args.destination))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/host/basic_host.py

@@ -145,6 +145,12 @@ class BasicHost(IHost):
                 addrs.append(addr.encapsulate(p2p_part))
         return addrs
 
+    def get_connected_peers(self) -> List[ID]:
+        """
+        :return: all the ids of peers this host is currently connected to
+        """
+        return list(self._network.connections.keys())
+
     @asynccontextmanager
     async def run(
         self, listen_addrs: Sequence[multiaddr.Multiaddr]

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/host/host_interface.py

@@ -71,6 +71,12 @@ class IHost(ABC):
         :return: all the multiaddr addresses this host is listening to
         """
 
+    @abstractmethod
+    def get_connected_peers(self) -> List[ID]:
+        """
+        :return: all the ids of peers this host is currently connected to
+        """
+
     @abstractmethod
     def run(
         self, listen_addrs: Sequence[multiaddr.Multiaddr]

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/host/ping.py

@@ -1,7 +1,15 @@
 import logging
+import secrets
+import time
+from typing import (
+    List,
+)
 
 import trio
 
+from libp2p.host.host_interface import (
+    IHost,
+)
 from libp2p.network.stream.exceptions import (
     StreamClosed,
     StreamEOF,
@@ -65,7 +73,42 @@ async def handle_ping(stream: INetStream) -> None:
         try:
             should_continue = await _handle_ping(stream, peer_id)
             if not should_continue:
+                await stream.close()
                 return
         except Exception:
             await stream.reset()
             return
+
+
+async def _ping(stream: INetStream) -> int:
+    """
+    Helper function to perform a single ping operation on a given stream,
+    returns integer value rtt - which denotes round trip time for a ping request in ms
+    """
+    ping_bytes = secrets.token_bytes(PING_LENGTH)
+    before = time.time()
+    await stream.write(ping_bytes)
+    pong_bytes = await stream.read(PING_LENGTH)
+    rtt = int((time.time() - before) * (10**6))
+    if ping_bytes != pong_bytes:
+        logger.debug("invalid pong response")
+        raise
+    return rtt
+
+
+class PingService:
+    """PingService executes pings and returns RTT in miliseconds."""
+
+    def __init__(self, host: IHost):
+        self._host = host
+
+    async def ping(self, peer_id: PeerID, ping_amt: int = 1) -> List[int]:
+        stream = await self._host.new_stream(peer_id, [ID])
+
+        try:
+            rtts = [await _ping(stream) for _ in range(ping_amt)]
+            await stream.close()
+            return rtts
+        except Exception:
+            await stream.close()
+            raise

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/peer/peerdata.py

@@ -55,7 +55,9 @@ class PeerData(IPeerData):
         """
         :param addrs: multiaddresses to add
         """
-        self.addrs.extend(addrs)
+        for addr in addrs:
+            if addr not in self.addrs:
+                self.addrs.append(addr)
 
     def get_addrs(self) -> List[Multiaddr]:
         """

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/pubsub/abc.py

@@ -66,6 +66,7 @@ class IPubsubRouter(ABC):
         Notifies the router that a new peer has been connected.
 
         :param peer_id: id of peer to add
+        :param protocol_id: router protocol the peer speaks, e.g., floodsub, gossipsub
         """
 
     @abstractmethod
@@ -81,10 +82,9 @@ class IPubsubRouter(ABC):
         """
         Invoked to process control messages in the RPC envelope.
         It is invoked after subscriptions and payload messages have been processed
-        TODO: Check if this interface is ok. It's not the exact same as the go code, but
-        the go code is really confusing with the msg origin, they specify `rpc.from`
-        even when the rpc shouldn't have a from
-        :param rpc: rpc message
+
+        :param rpc: RPC message
+        :param sender_peer_id: id of the peer who sent the message
         """
 
     @abstractmethod

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/pubsub/floodsub.py

@@ -75,10 +75,11 @@ class FloodSub(IPubsubRouter):
 
     async def handle_rpc(self, rpc: rpc_pb2.RPC, sender_peer_id: ID) -> None:
         """
-        Invoked to process control messages in the RPC envelope. It is invoked
-        after subscriptions and payload messages have been processed.
+        Invoked to process control messages in the RPC envelope.
+        It is invoked after subscriptions and payload messages have been processed
 
-        :param rpc: rpc message
+        :param rpc: RPC message
+        :param sender_peer_id: id of the peer who sent the message
         """
         # Checkpoint
         await trio.lowlevel.checkpoint()

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/pubsub/gossipsub.py

@@ -179,8 +179,8 @@ class GossipSub(IPubsubRouter, Service):
 
     async def handle_rpc(self, rpc: rpc_pb2.RPC, sender_peer_id: ID) -> None:
         """
-        Invoked to process control messages in the RPC envelope. It is invoked
-        after subscriptions and payload messages have been processed.
+        Invoked to process control messages in the RPC envelope.
+        It is invoked after subscriptions and payload messages have been processed
 
         :param rpc: RPC message
         :param sender_peer_id: id of the peer who sent the message

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p/pubsub/pubsub.py

@@ -643,6 +643,19 @@ class Pubsub(Service, IPubsub):
             return
 
         self._mark_msg_seen(msg)
+
+        # reject messages claiming to be from ourselves but not locally published
+        self_id = self.host.get_id()
+        if (
+            base58.b58encode(msg.from_id).decode() == self_id
+            and msg_forwarder != self_id
+        ):
+            logger.debug(
+                "dropping message claiming to be from self but forwarded from %s",
+                msg_forwarder,
+            )
+            return
+
         self.notify_subscriptions(msg)
         await self.router.publish(msg_forwarder, msg)
 

{libp2p-0.2.0 → libp2p-0.2.1/libp2p.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libp2p
-Version: 0.2.0
+Version: 0.2.1
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation
@@ -38,7 +38,7 @@ Requires-Dist: pymultihash>=0.8.2
 Requires-Dist: pynacl>=1.3.0
 Requires-Dist: rpcudp>=3.0.0
 Requires-Dist: trio-typing>=0.0.4
-Requires-Dist: trio>=0.15.0
+Requires-Dist: trio>=0.26.0
 Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
 Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
 Provides-Extra: dev

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ examples/chat/__init__.py
 examples/chat/chat.py
 examples/echo/__init__.py
 examples/echo/echo.py
+examples/ping/__init__.py
+examples/ping/ping.py
 libp2p/__init__.py
 libp2p/exceptions.py
 libp2p/py.typed
@@ -175,6 +177,7 @@ tests/core/crypto/test_ed25519.py
 tests/core/crypto/test_secp256k1.py
 tests/core/examples/test_examples.py
 tests/core/host/test_basic_host.py
+tests/core/host/test_connected_peers.py
 tests/core/host/test_ping.py
 tests/core/host/test_routed_host.py
 tests/core/identity/identify/test_protocol.py
@@ -185,6 +188,7 @@ tests/core/network/test_swarm.py
 tests/core/network/test_swarm_conn.py
 tests/core/peer/test_addrbook.py
 tests/core/peer/test_interop.py
+tests/core/peer/test_peerdata.py
 tests/core/peer/test_peerid.py
 tests/core/peer/test_peerinfo.py
 tests/core/peer/test_peermetadata.py

{libp2p-0.2.0 → libp2p-0.2.1}/libp2p.egg-info/requires.txt

@@ -10,7 +10,7 @@ pymultihash>=0.8.2
 pynacl>=1.3.0
 rpcudp>=3.0.0
 trio-typing>=0.0.4
-trio>=0.15.0
+trio>=0.26.0
 
 [:python_version < "3.11"]
 exceptiongroup>=1.2.0

{libp2p-0.2.0 → libp2p-0.2.1}/pyproject.toml

@@ -124,7 +124,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "0.2.0"
+current_version = "0.2.1"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{libp2p-0.2.0 → libp2p-0.2.1}/setup.py

@@ -66,7 +66,7 @@ install_requires = [
     "pynacl>=1.3.0",
     "rpcudp>=3.0.0",
     "trio-typing>=0.0.4",
-    "trio>=0.15.0",
+    "trio>=0.26.0",
 ]
 
 
@@ -80,7 +80,7 @@ if not readthedocs_is_building:
 setup(
     name="libp2p",
     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
-    version="0.2.0",
+    version="0.2.1",
     description="""libp2p: The Python implementation of the libp2p networking stack""",
     long_description=long_description,
     long_description_content_type="text/markdown",

libp2p-0.2.1/tests/core/host/test_connected_peers.py

@@ -0,0 +1,113 @@
+import pytest
+
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+from libp2p.tools.factories import (
+    HostFactory,
+)
+
+
+async def connect_two(host_a, host_b, host_c):
+    # Initially all of the hosts are disconnected
+    assert (len(host_a.get_connected_peers())) == 0
+    assert (len(host_b.get_connected_peers())) == 0
+    assert (len(host_c.get_connected_peers())) == 0
+
+    # Connecting hostA with hostB
+    addr = host_b.get_addrs()[0]
+    info = info_from_p2p_addr(addr)
+    await host_a.connect(info)
+
+    # Since hostA and hostB are connected now
+    assert (len(host_a.get_connected_peers())) == 1
+    assert (len(host_b.get_connected_peers())) == 1
+    assert (len(host_c.get_connected_peers())) == 0
+    assert host_a.get_connected_peers()[0] == host_b.get_id()
+    assert host_b.get_connected_peers()[0] == host_a.get_id()
+
+
+async def connect_three_cyclic(host_a, host_b, host_c):
+    # Connecting hostA with hostB
+    addr = host_b.get_addrs()[0]
+    infoB = info_from_p2p_addr(addr)
+    await host_a.connect(infoB)
+
+    # Connecting hostB with hostC
+    addr = host_c.get_addrs()[0]
+    infoC = info_from_p2p_addr(addr)
+    await host_b.connect(infoC)
+
+    # Connecting hostC with hostA
+    addr = host_a.get_addrs()[0]
+    infoA = info_from_p2p_addr(addr)
+    await host_c.connect(infoA)
+
+    # Performing checks
+    assert (len(host_a.get_connected_peers())) == 2
+    assert (len(host_b.get_connected_peers())) == 2
+    assert (len(host_c.get_connected_peers())) == 2
+    assert host_a.get_connected_peers() == [host_b.get_id(), host_c.get_id()]
+    assert host_b.get_connected_peers() == [host_a.get_id(), host_c.get_id()]
+    assert host_c.get_connected_peers() == [host_b.get_id(), host_a.get_id()]
+
+
+async def connect_two_to_one(host_a, host_b, host_c):
+    # Connecting hostA and hostC to hostB
+    addr = host_b.get_addrs()[0]
+    infoB = info_from_p2p_addr(addr)
+    await host_a.connect(infoB)
+    await host_c.connect(infoB)
+
+    # Performing checks
+    assert (len(host_a.get_connected_peers())) == 1
+    assert (len(host_b.get_connected_peers())) == 2
+    assert (len(host_c.get_connected_peers())) == 1
+    assert host_a.get_connected_peers() == [host_b.get_id()]
+    assert host_b.get_connected_peers() == [host_a.get_id(), host_c.get_id()]
+    assert host_c.get_connected_peers() == [host_b.get_id()]
+
+
+async def connect_and_disconnect(host_a, host_b, host_c):
+    # Connecting hostB to hostA and hostC
+    addr = host_a.get_addrs()[0]
+    infoA = info_from_p2p_addr(addr)
+    await host_b.connect(infoA)
+    addr = host_c.get_addrs()[0]
+    infoC = info_from_p2p_addr(addr)
+    await host_b.connect(infoC)
+
+    # Performing checks
+    assert (len(host_a.get_connected_peers())) == 1
+    assert (len(host_b.get_connected_peers())) == 2
+    assert (len(host_c.get_connected_peers())) == 1
+    assert host_a.get_connected_peers() == [host_b.get_id()]
+    assert host_b.get_connected_peers() == [host_a.get_id(), host_c.get_id()]
+    assert host_c.get_connected_peers() == [host_b.get_id()]
+
+    # Disconnecting hostB and hostA
+    await host_b.disconnect(host_a.get_id())
+
+    # Performing checks
+    assert (len(host_a.get_connected_peers())) == 0
+    assert (len(host_b.get_connected_peers())) == 1
+    assert (len(host_c.get_connected_peers())) == 1
+    assert host_b.get_connected_peers() == [host_c.get_id()]
+    assert host_c.get_connected_peers() == [host_b.get_id()]
+
+
+@pytest.mark.parametrize(
+    "test",
+    [
+        (connect_two),
+        (connect_three_cyclic),
+        (connect_two_to_one),
+        (connect_and_disconnect),
+    ],
+)
+@pytest.mark.trio
+async def test_connected_peers(test, security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        3, security_protocol=security_protocol
+    ) as hosts:
+        await test(hosts[0], hosts[1], hosts[2])

{libp2p-0.2.0 → libp2p-0.2.1}/tests/core/host/test_ping.py

@@ -6,6 +6,7 @@ import trio
 from libp2p.host.ping import (
     ID,
     PING_LENGTH,
+    PingService,
 )
 from libp2p.tools.factories import (
     host_pair_factory,
@@ -47,3 +48,28 @@ async def test_ping_several(security_protocol):
             # NOTE: this interval can be `0` for this test.
             await trio.sleep(0)
         await stream.close()
+
+
+@pytest.mark.trio
+async def test_ping_service_once(security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as (
+        host_a,
+        host_b,
+    ):
+        ping_service = PingService(host_b)
+        rtts = await ping_service.ping(host_a.get_id())
+        assert len(rtts) == 1
+        assert rtts[0] < 10**6
+
+
+@pytest.mark.trio
+async def test_ping_service_several(security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as (
+        host_a,
+        host_b,
+    ):
+        ping_service = PingService(host_b)
+        rtts = await ping_service.ping(host_a.get_id(), ping_amt=SOME_PING_COUNT)
+        assert len(rtts) == SOME_PING_COUNT
+        for rtt in rtts:
+            assert rtt < 10**6

libp2p-0.2.1/tests/core/peer/test_peerdata.py

@@ -0,0 +1,106 @@
+import pytest
+
+from libp2p.crypto.secp256k1 import (
+    create_new_key_pair,
+)
+from libp2p.peer.peerdata import (
+    PeerData,
+    PeerDataError,
+)
+
+MOCK_ADDR = "/peer"
+MOCK_KEYPAIR = create_new_key_pair()
+MOCK_PUBKEY = MOCK_KEYPAIR.public_key
+MOCK_PRIVKEY = MOCK_KEYPAIR.private_key
+
+
+# Test case when no protocols have been added
+def test_get_protocols_empty():
+    peer_data = PeerData()
+    assert peer_data.get_protocols() == []
+
+
+# Test case when adding protocols
+def test_add_protocols():
+    peer_data = PeerData()
+    protocols = ["protocol1", "protocol2"]
+    peer_data.add_protocols(protocols)
+    assert peer_data.get_protocols() == protocols
+
+
+# Test case when setting protocols
+def test_set_protocols():
+    peer_data = PeerData()
+    protocols = ["protocolA", "protocolB"]
+    peer_data.set_protocols(protocols)
+    assert peer_data.get_protocols() == protocols
+
+
+# Test case when adding addresses
+def test_add_addrs():
+    peer_data = PeerData()
+    addresses = [MOCK_ADDR]
+    peer_data.add_addrs(addresses)
+    assert peer_data.get_addrs() == addresses
+
+
+# Test case when adding same address more than once
+def test_add_dup_addrs():
+    peer_data = PeerData()
+    addresses = [MOCK_ADDR, MOCK_ADDR]
+    peer_data.add_addrs(addresses)
+    peer_data.add_addrs(addresses)
+    assert peer_data.get_addrs() == [MOCK_ADDR]
+
+
+# Test case for clearing addresses
+def test_clear_addrs():
+    peer_data = PeerData()
+    addresses = [MOCK_ADDR]
+    peer_data.add_addrs(addresses)
+    peer_data.clear_addrs()
+    assert peer_data.get_addrs() == []
+
+
+# Test case for adding metadata
+def test_put_metadata():
+    peer_data = PeerData()
+    key = "key1"
+    value = "value1"
+    peer_data.put_metadata(key, value)
+    assert peer_data.get_metadata(key) == value
+
+
+# Test case for key not found in metadata
+def test_get_metadata_key_not_found():
+    peer_data = PeerData()
+    with pytest.raises(PeerDataError):
+        peer_data.get_metadata("nonexistent_key")
+
+
+# Test case for adding public key
+def test_add_pubkey():
+    peer_data = PeerData()
+    peer_data.add_pubkey(MOCK_PUBKEY)
+    assert peer_data.get_pubkey() == MOCK_PUBKEY
+
+
+# Test case when public key is not set
+def test_get_pubkey_not_found():
+    peer_data = PeerData()
+    with pytest.raises(PeerDataError):
+        peer_data.get_pubkey()
+
+
+# Test case for adding private key
+def test_add_privkey():
+    peer_data = PeerData()
+    peer_data.add_privkey(MOCK_PRIVKEY)
+    assert peer_data.get_privkey() == MOCK_PRIVKEY
+
+
+# Test case when private key is not set
+def test_get_privkey_not_found():
+    peer_data = PeerData()
+    with pytest.raises(PeerDataError):
+        peer_data.get_privkey()

{libp2p-0.2.0 → libp2p-0.2.1}/tests/core/protocol_muxer/test_protocol_muxer.py

@@ -67,7 +67,7 @@ async def test_single_protocol_fails(security_protocol):
 
     # the StreamFailure is within 2 nested ExceptionGroups, so we use strict=False
     # to unwrap down to the core Exception
-    with RaisesGroup(StreamFailure, strict=False):
+    with RaisesGroup(StreamFailure, allow_unwrapped=True, flatten_subgroups=True):
         await perform_simple_test(
             "", [PROTOCOL_ECHO], [PROTOCOL_POTATO], security_protocol
         )
@@ -112,7 +112,7 @@ async def test_multiple_protocol_fails(security_protocol):
 
     # the StreamFailure is within 2 nested ExceptionGroups, so we use strict=False
     # to unwrap down to the core Exception
-    with RaisesGroup(StreamFailure, strict=False):
+    with RaisesGroup(StreamFailure, allow_unwrapped=True, flatten_subgroups=True):
         await perform_simple_test(
             "", protocols_for_client, protocols_for_listener, security_protocol
         )