added: logs

Author: lla-dane

interop/arch.py

@@ -15,18 +15,25 @@
 from libp2p.crypto.rsa import (
     create_new_key_pair,
 )
+from libp2p.crypto.x25519 import create_new_key_pair as create_new_x25519_key_pair
 from libp2p.custom_types import (
     TProtocol,
 )
 from libp2p.security.insecure.transport import (
     PLAINTEXT_PROTOCOL_ID,
     InsecureTransport,
 )
+from libp2p.security.noise.transport import PROTOCOL_ID as NOISE_PROTOCOL_ID
+from libp2p.security.noise.transport import Transport as NoiseTransport
 import libp2p.security.secio.transport as secio
 from libp2p.stream_muxer.mplex.mplex import (
     MPLEX_PROTOCOL_ID,
     Mplex,
 )
+from libp2p.stream_muxer.yamux.yamux import (
+    Yamux,
+)
+from libp2p.stream_muxer.yamux.yamux import PROTOCOL_ID as YAMUX_PROTOCOL_ID
 
 
 def generate_new_rsa_identity() -> KeyPair:
@@ -39,14 +46,41 @@ async def build_host(transport: str, ip: str, port: str, sec_protocol: str, muxe
             key_pair = create_new_key_pair()
             host = new_host(
                 key_pair,
-                {MPLEX_PROTOCOL_ID: Mplex},
+                {TProtocol(MPLEX_PROTOCOL_ID): Mplex},
+                {
+                    TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair),
+                    TProtocol(secio.ID): secio.Transport(key_pair),
+                },
+            )
+            muladdr = multiaddr.Multiaddr(f"/ip4/{ip}/tcp/{port}")
+            return (host, muladdr)
+        case ("insecure", "yamux"):
+            key_pair = create_new_key_pair()
+            host = new_host(
+                key_pair,
+                {TProtocol(YAMUX_PROTOCOL_ID): Yamux},
                 {
                     TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair),
                     TProtocol(secio.ID): secio.Transport(key_pair),
                 },
             )
             muladdr = multiaddr.Multiaddr(f"/ip4/{ip}/tcp/{port}")
             return (host, muladdr)
+        case ("noise", "yamux"):
+            key_pair = create_new_key_pair()
+            noise_key_pair = create_new_x25519_key_pair()
+
+            host = new_host(
+                key_pair,
+                {TProtocol(YAMUX_PROTOCOL_ID): Yamux},
+                {
+                    NOISE_PROTOCOL_ID: NoiseTransport(
+                        key_pair, noise_privkey=noise_key_pair.private_key
+                    )
+                },
+            )
+            muladdr = multiaddr.Multiaddr(f"/ip4/{ip}/tcp/{port}")
+            return (host, muladdr)
         case _:
             raise ValueError("Protocols not supported")
 

interop/lib.py

@@ -89,10 +89,18 @@ async def run_test(
 
             handshake_start = time.perf_counter()
 
+            logger.info("GETTING READY FOR CONNECTION")
             await host.connect(info)
+            logger.info("HOST CONNECTED")
+
+            # TILL HERE EVERYTHING IS FINE
+
             stream = await host.new_stream(info.peer_id, [PING_PROTOCOL_ID])
+            logger.info("CREATED NEW STREAM")
 
+            # DOES NOT MORE FORWARD FROM THIS
             logger.info("Remote conection established")
+
             nursery.start_soon(send_ping, stream)
 
             handshake_plus_ping = (time.perf_counter() - handshake_start) * 1000.0

libp2p/host/basic_host.py

@@ -6,7 +6,6 @@
     AbstractAsyncContextManager,
     asynccontextmanager,
 )
-import logging
 from typing import (
     TYPE_CHECKING,
     Optional,
@@ -69,7 +68,10 @@
 # telling it to listen on the given listen addresses.
 
 
-logger = logging.getLogger("libp2p.network.basic_host")
+# logger = logging.getLogger("libp2p.network.basic_host")
+from loguru import (
+    logger,
+)
 
 
 class BasicHost(IHost):
@@ -186,12 +188,15 @@ async def new_stream(
         :return: stream: new stream created
         """
         net_stream = await self._network.new_stream(peer_id)
-
+        logger.info("INETSTREAM CHECKING IN")
+        logger.info(protocol_ids)
         # Perform protocol muxing to determine protocol to use
         try:
+            logger.debug("PROTOCOLS TRYING TO GET SENT")
             selected_protocol = await self.multiselect_client.select_one_of(
                 list(protocol_ids), MultiselectCommunicator(net_stream)
             )
+            logger.info("PROTOCOLS GOT SENT")
         except MultiselectClientError as error:
             logger.debug("fail to open a stream to peer %s, error=%s", peer_id, error)
             await net_stream.reset()

libp2p/network/swarm.py

@@ -1,5 +1,9 @@
 import logging
 
+# logger = logging.getLogger("libp2p.network.swarm")
+from loguru import (
+    logger,
+)
 from multiaddr import (
     Multiaddr,
 )
@@ -52,8 +56,6 @@
     SwarmException,
 )
 
-logger = logging.getLogger("libp2p.network.swarm")
-
 
 def create_default_stream_handler(network: INetworkService) -> StreamHandlerFn:
     async def stream_handler(stream: INetStream) -> None:
@@ -127,6 +129,7 @@ async def dial_peer(self, peer_id: ID) -> INetConn:
         :return: muxed connection
         """
         if peer_id in self.connections:
+            logger.info("WE ARE RETURNING, PEER ALREADAY EXISTS")
             # If muxed connection already exists for peer_id,
             # set muxed connection equal to existing muxed connection
             return self.connections[peer_id]
@@ -147,6 +150,7 @@ async def dial_peer(self, peer_id: ID) -> INetConn:
         # Try all known addresses
         for multiaddr in addrs:
             try:
+                logger.info("HANDSHAKE GOING TO HAPPEN")
                 return await self.dial_addr(multiaddr, peer_id)
             except SwarmException as e:
                 exceptions.append(e)
@@ -221,8 +225,11 @@ async def new_stream(self, peer_id: ID) -> INetStream:
         logger.debug("attempting to open a stream to peer %s", peer_id)
 
         swarm_conn = await self.dial_peer(peer_id)
+        logger.info("INETCONN CREATED")
 
         net_stream = await swarm_conn.new_stream()
+        logger.info("INETSTREAM CREATED")
+
         logger.debug("successfully opened a stream to peer %s", peer_id)
         return net_stream
 

libp2p/protocol_muxer/multiselect_client.py

@@ -2,6 +2,10 @@
     Sequence,
 )
 
+from loguru import (
+    logger,
+)
+
 from libp2p.abc import (
     IMultiselectClient,
     IMultiselectCommunicator,
@@ -36,11 +40,15 @@ async def handshake(self, communicator: IMultiselectCommunicator) -> None:
         try:
             await communicator.write(MULTISELECT_PROTOCOL_ID)
         except MultiselectCommunicatorError as error:
+            logger.error("WROTE FAIL")
             raise MultiselectClientError() from error
 
+        logger.info(f"WROTE SUC, {MULTISELECT_PROTOCOL_ID}")
         try:
             handshake_contents = await communicator.read()
+            logger.info(f"READ SUC, {handshake_contents}")
         except MultiselectCommunicatorError as error:
+            logger.error(f"READ FAIL, {error}")
             raise MultiselectClientError() from error
 
         if not is_valid_handshake(handshake_contents):
@@ -59,9 +67,12 @@ async def select_one_of(
         :return: selected protocol
         :raise MultiselectClientError: raised when protocol negotiation failed
         """
+        logger.info("TRYING TO GET THE HANDSHAKE HAPPENED")
         await self.handshake(communicator)
+        logger.info("HANDSHAKE HAPPENED")
 
         for protocol in protocols:
+            logger.info(protocol)
             try:
                 selected_protocol = await self.try_select(communicator, protocol)
                 return selected_protocol
@@ -113,11 +124,17 @@ async def try_select(
         """
         try:
             await communicator.write(protocol)
+            from loguru import (
+                logger,
+            )
+
+            logger.info(protocol)
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error
 
         try:
             response = await communicator.read()
+            logger.info("Response: ", response)
         except MultiselectCommunicatorError as error:
             raise MultiselectClientError() from error