refactor: limit FindNodeReq responses to K_VALUE (#5971)

Change related to discussion:
#5969

---------

Co-authored-by: guillaumemichel <[email protected]>
Co-authored-by: Guillaume Michel <[email protected]>

Author: mickvandijke

protocols/kad/src/behaviour.rs

@@ -720,7 +720,7 @@ where
     where
         K: Into<kbucket::Key<K>> + Into<Vec<u8>> + Clone,
     {
-        self.get_closest_peers_inner(key, None)
+        self.get_closest_peers_inner(key, K_VALUE)
     }
 
     /// Initiates an iterative query for the closest peers to the given key.
@@ -738,10 +738,10 @@ where
         // since it would involve forging a new key and additional requests.
         // Hence bound to K_VALUE here to set clear expectation and prevent unexpected behaviour.
         let capped_num_results = std::cmp::min(num_results, K_VALUE);
-        self.get_closest_peers_inner(key, Some(capped_num_results))
+        self.get_closest_peers_inner(key, capped_num_results)
     }
 
-    fn get_closest_peers_inner<K>(&mut self, key: K, num_results: Option<NonZeroUsize>) -> QueryId
+    fn get_closest_peers_inner<K>(&mut self, key: K, num_results: NonZeroUsize) -> QueryId
     where
         K: Into<kbucket::Key<K>> + Into<Vec<u8>> + Clone,
     {
@@ -778,7 +778,7 @@ where
         self.kbuckets
             .closest(key)
             .filter(move |e| e.node.key.preimage() != source)
-            .take(self.queries.config().replication_factor.get())
+            .take(K_VALUE.get())
             .map(KadPeer::from)
     }
 
@@ -3205,8 +3205,8 @@ pub enum QueryInfo {
         key: Vec<u8>,
         /// Current index of events.
         step: ProgressStep,
-        /// If required, `num_results` specifies expected responding peers
-        num_results: Option<NonZeroUsize>,
+        /// Specifies expected number of responding peers
+        num_results: NonZeroUsize,
     },
 
     /// A (repeated) query initiated by [`Behaviour::get_providers`].

protocols/kad/src/behaviour/test.rs

@@ -1606,3 +1606,60 @@ fn get_providers_limit_n_2() {
 fn get_providers_limit_n_5() {
     get_providers_limit::<5>();
 }
+
+// Test that nodes respond with K amount of peers even when replication factor is set lower than K.
+#[test]
+fn get_closest_peers_should_return_up_to_k_peers() {
+    let k_value = K_VALUE.get();
+
+    // Rplication factor should not influence the amount of peers returned in `GetClosestPeers`.
+    for replication_factor in 5..k_value + 1 {
+        // Should be enough nodes for every node to have >= K nodes in their RT.
+        let num_of_nodes = 3 * k_value;
+
+        let mut cfg = Config::new(PROTOCOL_NAME);
+        cfg.set_replication_factor(NonZeroUsize::new(replication_factor).unwrap());
+
+        let swarms = build_connected_nodes_with_config(num_of_nodes, replication_factor - 1, cfg);
+        let mut swarms = swarms
+            .into_iter()
+            .map(|(_addr, swarm)| swarm)
+            .collect::<Vec<_>>();
+
+        // Ask first node to search for a random peer.
+        let search_target = PeerId::random();
+        swarms[0].behaviour_mut().get_closest_peers(search_target);
+
+        block_on(poll_fn(move |ctx| {
+            for swarm in &mut swarms {
+                loop {
+                    match swarm.poll_next_unpin(ctx) {
+                        Poll::Ready(Some(SwarmEvent::Behaviour(
+                            Event::OutboundQueryProgressed {
+                                result: QueryResult::GetClosestPeers(Ok(ok)),
+                                ..
+                            },
+                        ))) => {
+                            assert_eq!(&ok.key[..], search_target.to_bytes().as_slice());
+                            // Verify that we get K_VALUE amount of peers even with lower
+                            // replication factor.
+                            assert_eq!(
+                                ok.peers.len(),
+                                k_value,
+                                "Expected K_VALUE ({}) peers but got {}",
+                                k_value,
+                                ok.peers.len()
+                            );
+                            return Poll::Ready(());
+                        }
+                        // Ignore any other event.
+                        Poll::Ready(Some(_)) => (),
+                        e @ Poll::Ready(_) => panic!("Unexpected return value: {e:?}"),
+                        Poll::Pending => break,
+                    }
+                }
+            }
+            Poll::Pending
+        }))
+    }
+}

protocols/kad/src/query.rs

@@ -143,9 +143,9 @@ impl QueryPool {
     {
         let num_results = match info {
             QueryInfo::GetClosestPeers {
-                num_results: Some(val),
-                ..
+                num_results: val, ..
             } => val,
+            QueryInfo::Bootstrap { .. } => K_VALUE,
             _ => self.config.replication_factor,
         };