Add test for kademlia client mode

Author: thomaseizinger

Cargo.lock

@@ -34,9 +34,13 @@ serde = { version = "1.0", optional = true, features = ["derive"] }
 thiserror = "1"
 
 [dev-dependencies]
+async-std = { version = "1.12.0", features = ["attributes"] }
 env_logger = "0.10.0"
 futures-timer = "3.0"
+libp2p-identify = { path = "../identify" }
 libp2p-noise = { path = "../../transports/noise" }
+libp2p-swarm = { path = "../../swarm", features = ["macros"] }
+libp2p-swarm-test = { path = "../../swarm-test" }
 libp2p-yamux = { path = "../../muxers/yamux" }
 quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 

protocols/kad/Cargo.toml

@@ -116,6 +116,7 @@ pub struct Kademlia<TStore> {
 
     /// The record storage.
     store: TStore,
+    mode: Mode,
 }
 
 /// The configurable strategies for the insertion of peers
@@ -182,6 +183,7 @@ pub struct KademliaConfig {
     connection_idle_timeout: Duration,
     kbucket_inserts: KademliaBucketInserts,
     caching: KademliaCaching,
+    mode: Mode,
 }
 
 impl Default for KademliaConfig {
@@ -199,6 +201,7 @@ impl Default for KademliaConfig {
             connection_idle_timeout: Duration::from_secs(10),
             kbucket_inserts: KademliaBucketInserts::OnConnected,
             caching: KademliaCaching::Enabled { max_peers: 1 },
+            mode: Mode::Server,
         }
     }
 }
@@ -399,6 +402,14 @@ impl KademliaConfig {
         self.caching = c;
         self
     }
+
+    /// Sets the mode.
+    ///
+    /// TODO: More docs.
+    pub fn set_mode(&mut self, m: Mode) -> &mut Self {
+        self.mode = m;
+        self
+    }
 }
 
 impl<TStore> Kademlia<TStore>
@@ -453,6 +464,7 @@ where
             connection_idle_timeout: config.connection_idle_timeout,
             external_addresses: Default::default(),
             local_peer_id: id,
+            mode: config.mode,
         }
     }
 
@@ -1976,7 +1988,7 @@ where
         Ok(KademliaHandler::new(
             KademliaHandlerConfig {
                 protocol_config: self.protocol_config.clone(),
-                allow_listening: true,
+                allow_listening: self.mode == Mode::Server,
                 idle_timeout: self.connection_idle_timeout,
             },
             ConnectedPoint::Listener {
@@ -1997,7 +2009,7 @@ where
         Ok(KademliaHandler::new(
             KademliaHandlerConfig {
                 protocol_config: self.protocol_config.clone(),
-                allow_listening: true,
+                allow_listening: self.mode == Mode::Server,
                 idle_timeout: self.connection_idle_timeout,
             },
             ConnectedPoint::Dialer {
@@ -3190,3 +3202,9 @@ pub enum RoutingUpdate {
     /// peer ID).
     Failed,
 }
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Mode {
+    Client,
+    Server,
+}

protocols/kad/src/behaviour.rs

@@ -789,25 +789,7 @@ where
             ConnectionEvent::AddressChange(_)
             | ConnectionEvent::ListenUpgradeError(_)
             | ConnectionEvent::LocalProtocolsChange(_) => {}
-            ConnectionEvent::RemoteProtocolsChange(ProtocolsChange { protocols }) => {
-                // TODO: We should cache this / it will get simpler with #2831.
-                let kademlia_protocols = self
-                    .config
-                    .protocol_config
-                    .protocol_names()
-                    .iter()
-                    .filter_map(|b| String::from_utf8(b.to_vec()).ok())
-                    .collect::<Vec<_>>();
-
-                let remote_supports_our_kademlia_protocols =
-                    kademlia_protocols.iter().all(|p| protocols.contains(p));
-
-                if remote_supports_our_kademlia_protocols {
-                    self.protocol_status = ProtocolStatus::Confirmed;
-                } else {
-                    self.protocol_status = ProtocolStatus::NotSupported;
-                }
-            }
+            ConnectionEvent::RemoteProtocolsChange(_) => {}
         }
     }
 }

protocols/kad/src/handler.rs

@@ -61,7 +61,7 @@ pub use behaviour::{
     AddProviderContext, AddProviderError, AddProviderOk, AddProviderPhase, AddProviderResult,
     BootstrapError, BootstrapOk, BootstrapResult, GetClosestPeersError, GetClosestPeersOk,
     GetClosestPeersResult, GetProvidersError, GetProvidersOk, GetProvidersResult, GetRecordError,
-    GetRecordOk, GetRecordResult, InboundRequest, NoKnownPeers, PeerRecord, PutRecordContext,
+    GetRecordOk, GetRecordResult, InboundRequest, Mode, NoKnownPeers, PeerRecord, PutRecordContext,
     PutRecordError, PutRecordOk, PutRecordPhase, PutRecordResult, QueryInfo, QueryMut, QueryRef,
     QueryResult, QueryStats,
 };

protocols/kad/src/lib.rs

@@ -0,0 +1,59 @@
+use libp2p_identify as identify;
+use libp2p_identity as identity;
+use libp2p_kad::store::MemoryStore;
+use libp2p_kad::{Kademlia, KademliaConfig, KademliaEvent, Mode};
+use libp2p_swarm::Swarm;
+use libp2p_swarm_test::SwarmExt;
+
+#[async_std::test]
+async fn connection_to_node_in_client_mode_does_not_update_routing_table() {
+    let mut client = Swarm::new_ephemeral(MyBehaviour::client);
+    let mut server = Swarm::new_ephemeral(MyBehaviour::server);
+
+    server.listen().await;
+    client.connect(&mut server).await;
+
+    let server_peer_id = *server.local_peer_id();
+
+    match libp2p_swarm_test::drive(&mut client, &mut server).await {
+        (
+            [MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(_), MyBehaviourEvent::Kad(KademliaEvent::RoutingUpdated { peer, .. })],
+            [MyBehaviourEvent::Identify(_), MyBehaviourEvent::Identify(_)],
+        ) => {
+            assert_eq!(peer, server_peer_id)
+        }
+        other => panic!("Unexpected events: {other:?}"),
+    }
+}
+
+#[derive(libp2p_swarm::NetworkBehaviour)]
+#[behaviour(prelude = "libp2p_swarm::derive_prelude")]
+struct MyBehaviour {
+    identify: identify::Behaviour,
+    kad: Kademlia<MemoryStore>,
+}
+
+impl MyBehaviour {
+    fn client(k: identity::Keypair) -> Self {
+        let mut config = KademliaConfig::default();
+        config.set_mode(Mode::Client);
+
+        Self::with_config(k, config)
+    }
+
+    fn server(k: identity::Keypair) -> Self {
+        Self::with_config(k, KademliaConfig::default())
+    }
+
+    fn with_config(k: identity::Keypair, config: KademliaConfig) -> MyBehaviour {
+        let local_peer_id = k.public().to_peer_id();
+
+        Self {
+            identify: identify::Behaviour::new(identify::Config::new(
+                "/test/1.0.0".to_owned(),
+                k.public(),
+            )),
+            kad: Kademlia::with_config(local_peer_id, MemoryStore::new(local_peer_id), config),
+        }
+    }
+}