Enhancement: Fix Kademlia DHT Bootstrap by Using Connected Peers as Fallback

examples/floodsub/basic_example.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Basic FloodSub Example
+
+This is a simple example that demonstrates FloodSub publishing and subscribing
+without relying on test utilities. It shows the core functionality.
+
+Run this example with:
+    python examples/floodsub/basic_example.py
+"""
+
+import logging
+import sys
+
+from multiaddr import Multiaddr
+import trio
+
+from libp2p import new_host
+from libp2p.crypto.secp256k1 import create_new_key_pair
+from libp2p.pubsub.floodsub import FloodSub
+from libp2p.pubsub.pubsub import Pubsub
+from libp2p.tools.async_service import background_trio_service
+from libp2p.tools.constants import FLOODSUB_PROTOCOL_ID
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("floodsub_basic")
+
+
+async def main() -> None:
+    """Main function demonstrating basic FloodSub functionality."""
+    logger.info("Starting basic FloodSub example...")
+
+    # Create two hosts
+    key_pair1 = create_new_key_pair()
+    key_pair2 = create_new_key_pair()
+    host1 = new_host(
+        key_pair=key_pair1,
+        listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")],
+    )
+
+    host2 = new_host(
+        key_pair=key_pair2,
+        listen_addrs=[Multiaddr("/ip4/127.0.0.1/tcp/0")],
+    )
+
+    # Create FloodSub routers
+    floodsub1 = FloodSub(protocols=[FLOODSUB_PROTOCOL_ID])
+    floodsub2 = FloodSub(protocols=[FLOODSUB_PROTOCOL_ID])
+
+    # Create Pubsub instances
+    pubsub1 = Pubsub(
+        host=host1,
+        router=floodsub1,
+        strict_signing=False,  # Disable for simplicity
+    )
+
+    pubsub2 = Pubsub(
+        host=host2,
+        router=floodsub2,
+        strict_signing=False,  # Disable for simplicity
+    )
+
+    # Start both pubsub services
+    async with background_trio_service(pubsub1):
+        async with background_trio_service(pubsub2):
+            await pubsub1.wait_until_ready()
+            await pubsub2.wait_until_ready()
+
+            logger.info(f"Host 1 ID: {host1.get_id()}")
+            logger.info(f"Host 2 ID: {host2.get_id()}")
+
+            # Start listening on both hosts
+            logger.info("Starting hosts...")
+            await host1.get_network().listen()
+            await host2.get_network().listen()
+            await trio.sleep(0.5)  # Wait for hosts to start listening
+
+            # Connect the hosts
+            logger.info("Connecting hosts...")
+            from libp2p.peer.peerinfo import info_from_p2p_addr
+
+            peer_info = info_from_p2p_addr(
+                host2.get_addrs()[0].encapsulate(
+                    Multiaddr(f"/p2p/{host2.get_id().pretty()}")
+                )
+            )
+            await host1.connect(peer_info)
+            await trio.sleep(1)  # Wait for connection
+
+            # Subscribe to topic on host2
+            topic = "test-topic"
+            logger.info(f"Subscribing to topic: {topic}")
+            subscription = await pubsub2.subscribe(topic)
+            await trio.sleep(0.5)  # Wait for subscription to propagate
+
+            # Publish messages from host1
+            messages = [
+                "Hello from FloodSub!",
+                "This is message number 2",
+                "FloodSub is working great!",
+            ]
+
+            for i, message in enumerate(messages):
+                logger.info(f"Publishing message {i + 1}: {message}")
+                await pubsub1.publish(topic, message.encode())
+                await trio.sleep(0.5)
+
+            # Receive messages on host2
+            logger.info("Receiving messages...")
+            for i in range(len(messages)):
+                message = await subscription.get()
+                logger.info(f"Received message {i + 1}: {message.data.decode()}")
+                logger.info(f"  From peer: {message.from_id.hex()}")
+                logger.info(f"  Topics: {message.topicIDs}")
+
+    logger.info("Basic FloodSub example completed successfully!")
+
+
+if __name__ == "__main__":
+    try:
+        trio.run(main)
+    except KeyboardInterrupt:
+        logger.info("Example interrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Example failed: {e}")
+        sys.exit(1)

libp2p/__init__.py

@@ -183,7 +183,7 @@ def new_swarm(
     tls_client_config: ssl.SSLContext | None = None,
     tls_server_config: ssl.SSLContext | None = None,
 ) -> INetworkService:
-    logger.debug(f"new_swarm: enable_quic={enable_quic}, listen_addrs={listen_addrs}")
+    logger.debug("new_swarm: enable_quic=%s, listen_addrs=%s", enable_quic, listen_addrs)
     """
     Create a swarm instance based on the parameters.
 
@@ -227,7 +227,7 @@ def new_swarm(
         )
 
         addr = listen_addrs[0]
-        logger.debug(f"new_swarm: Creating transport for address: {addr}")
+        logger.debug("new_swarm: Creating transport for address: %s", addr)
         transport_maybe = create_transport_for_multiaddr(
             addr,
             temp_upgrader,
@@ -241,14 +241,17 @@ def new_swarm(
             raise ValueError(f"Unsupported transport for listen_addrs: {listen_addrs}")
 
         transport = transport_maybe
-        logger.debug(f"new_swarm: Created transport: {type(transport)}")
+    logger.debug("new_swarm: Created transport: %s", type(transport))
 
     # If enable_quic is True but we didn't get a QUIC transport, force QUIC
     if enable_quic and not isinstance(transport, QUICTransport):
-        logger.debug(f"new_swarm: Forcing QUIC transport (enable_quic=True but got {type(transport)})")
+        logger.debug(
+            "new_swarm: Forcing QUIC transport (enable_quic=True but got %s)",
+            type(transport),
+        )
         transport = QUICTransport(key_pair.private_key, config=quic_transport_opt)
 
-    logger.debug(f"new_swarm: Final transport type: {type(transport)}")
+    logger.debug("new_swarm: Final transport type: %s", type(transport))
 
     # Generate X25519 keypair for Noise
     noise_key_pair = create_new_x25519_key_pair()