fix(connection-pool): Keep only fluence peers in the connection pool

connection-pool/src/behaviour.rs

@@ -250,12 +250,12 @@ impl ConnectionPoolBehaviour {
         self.subscribers.push(outlet);
     }
 
-    pub fn add_discovered_addresses(&mut self, peer_id: PeerId, addresses: Vec<Multiaddr>) {
+    pub fn add_discovered_addresses(&mut self, peer_id: PeerId, addresses: &Vec<Multiaddr>) {
         self.contacts
             .entry(peer_id)
             .or_default()
             .discovered
-            .extend(addresses);
+            .extend(addresses.to_vec());
     }
 
     fn meter<U, F: Fn(&ConnectionPoolMetrics) -> U>(&self, f: F) {

crates/kademlia/src/behaviour.rs

@@ -160,7 +160,7 @@ impl Kademlia {
         }
     }
 
-    pub fn add_kad_node(&mut self, peer: PeerId, addresses: Vec<Multiaddr>) {
+    pub fn add_kad_node(&mut self, peer: PeerId, addresses: &Vec<Multiaddr>) {
         for addr in addresses {
             self.kademlia.add_address(&peer, addr.clone());
         }

particle-node/src/behaviour/identify.rs

@@ -19,6 +19,7 @@ use libp2p::{
     core::{multiaddr::Protocol, Multiaddr},
     identify::Event as IdentifyEvent,
 };
+use particle_protocol::PROTOCOL_NAME;
 
 use super::FluenceNetworkBehaviour;
 
@@ -36,17 +37,42 @@ impl FluenceNetworkBehaviour {
                     info.listen_addrs
                 );
 
-                let addresses = filter_addresses(info.listen_addrs, allow_local_addresses);
+                let addresses = filter_addresses(&info.listen_addrs, allow_local_addresses);
 
-                // Add addresses to connection pool disregarding whether it supports kademlia or not
-                // we want to have full info on non-kademlia peers as well
-                self.connection_pool
-                    .add_discovered_addresses(peer_id, addresses.clone());
+                let mut supports_kademlia = false;
+                let mut supports_fluence = false;
 
-                let supports_kademlia =
-                    info.protocols.iter().any(|p| p.contains("/ipfs/kad/1.0.0"));
-                if supports_kademlia {
-                    self.kademlia.add_kad_node(peer_id, addresses);
+                for protocol in info.protocols.iter() {
+                    if !supports_kademlia && protocol.contains("/ipfs/kad/1.0.0") {
+                        supports_kademlia = true;
+                    }
+                    if !supports_fluence && protocol.contains(PROTOCOL_NAME) {
+                        supports_fluence = true;
+                    }
+                    if supports_fluence && supports_kademlia {
+                        break;
+                    }
+                }
+
+                if supports_fluence {
+                    log::debug!(target: "network", "Found fluence peer {}: : protocols: {:?} version: {} listen addrs {:?}", peer_id, info.protocols,
+                    info.protocol_version,
+                    info.listen_addrs);
+                    // Add addresses to connection pool disregarding whether it supports kademlia or not
+                    // we want to have full info on non-kademlia peers as well
+                    self.connection_pool
+                        .add_discovered_addresses(peer_id, &addresses);
+                    if supports_kademlia {
+                        self.kademlia.add_kad_node(peer_id, &addresses);
+                    }
+                } else {
+                    log::debug!(
+                        target: "protocols",
+                        "Found peer {} not supported fluence protocol, protocols: {:?} version: {} listen addrs {:?}. skipping...",
+                        peer_id, info.protocols,
+                    info.protocol_version,
+                    info.listen_addrs
+                    );
                 }
             }
 
@@ -61,18 +87,18 @@ impl FluenceNetworkBehaviour {
     }
 }
 
-fn filter_addresses(addresses: Vec<Multiaddr>, allow_local: bool) -> Vec<Multiaddr> {
+fn filter_addresses(addresses: &Vec<Multiaddr>, allow_local: bool) -> Vec<Multiaddr> {
     // Deduplicate addresses
-    let addresses: Vec<_> = addresses.into_iter().unique().collect();
+    let addresses = addresses.into_iter().unique();
 
     if allow_local {
         // Return all addresses
-        addresses
+        addresses.cloned().collect()
     } else {
         // Keep only global addresses
         addresses
-            .into_iter()
             .filter(|maddr| !is_local_maddr(maddr))
+            .cloned()
             .collect()
     }
 }