feat(identify): make timeout and concurrent streams configurable

Cargo.toml

@@ -84,7 +84,7 @@ libp2p-dcutr = { version = "0.12.0", path = "protocols/dcutr" }
 libp2p-dns = { version = "0.42.0", path = "transports/dns" }
 libp2p-floodsub = { version = "0.45.0", path = "protocols/floodsub" }
 libp2p-gossipsub = { version = "0.48.0", path = "protocols/gossipsub" }
-libp2p-identify = { version = "0.45.1", path = "protocols/identify" }
+libp2p-identify = { version = "0.45.2", path = "protocols/identify" }
 libp2p-identity = { version = "0.2.9" }
 libp2p-kad = { version = "0.47.0", path = "protocols/kad" }
 libp2p-mdns = { version = "0.46.0", path = "protocols/mdns" }

protocols/identify/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.45.2
+
+- Make stream timeout and maximum number of concurrent streams configurable on identify.
+  See [PR 5654](https://github.com/libp2p/rust-libp2p/pull/5654).
+
 ## 0.45.1
 
 - Add `hide_listen_addrs` option to prevent leaking (local) listen addresses.

protocols/identify/Cargo.toml

@@ -3,7 +3,7 @@ name = "libp2p-identify"
 edition = "2021"
 rust-version = { workspace = true }
 description = "Nodes identification protocol for libp2p"
-version = "0.45.1"
+version = "0.45.2"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

protocols/identify/src/behaviour.rs

@@ -42,6 +42,9 @@ use std::{
     time::Duration,
 };
 
+const STREAM_TIMEOUT: Duration = Duration::from_secs(60);
+const MAX_CONCURRENT_STREAMS_PER_CONNECTION: usize = 10;
+
 /// Whether an [`Multiaddr`] is a valid for the QUIC transport.
 fn is_quic_addr(addr: &Multiaddr, v1: bool) -> bool {
     use Protocol::*;
@@ -153,6 +156,17 @@ pub struct Config {
     ///
     /// Disabled by default.
     pub hide_listen_addrs: bool,
+
+    /// Maximum duration for which an identification request stream may remain
+    /// active before timing out.
+    ///
+    /// Defaults to 1 minute.
+    pub stream_timeout: Duration,
+
+    /// Maximum number of concurrent identification request streams per connection.
+    ///
+    /// Defaults to 10.
+    pub max_concurrent_streams_per_connection: usize,
 }
 
 impl Config {
@@ -167,6 +181,8 @@ impl Config {
             push_listen_addr_updates: false,
             cache_size: 100,
             hide_listen_addrs: false,
+            stream_timeout: STREAM_TIMEOUT,
+            max_concurrent_streams_per_connection: MAX_CONCURRENT_STREAMS_PER_CONNECTION,
         }
     }
 
@@ -202,6 +218,20 @@ impl Config {
         self.hide_listen_addrs = b;
         self
     }
+
+    /// Configures maximum allowed duration for which an active identification request
+    /// stream is allowed to timeout.
+    pub fn with_stream_timeout(mut self, t: Duration) -> Self {
+        self.stream_timeout = t;
+        self
+    }
+
+    /// Configures the maximum number of concurrent identification request streams
+    /// allowed per connection.
+    pub fn with_max_concurrent_streams_per_connection(mut self, s: usize) -> Self {
+        self.max_concurrent_streams_per_connection = s;
+        self
+    }
 }
 
 impl Behaviour {
@@ -350,6 +380,8 @@ impl NetworkBehaviour for Behaviour {
             self.config.agent_version.clone(),
             remote_addr.clone(),
             self.all_addresses(),
+            self.config.stream_timeout,
+            self.config.max_concurrent_streams_per_connection,
         ))
     }
 
@@ -382,6 +414,8 @@ impl NetworkBehaviour for Behaviour {
             self.config.agent_version.clone(),
             addr.clone(), // TODO: This is weird? That is the public address we dialed, shouldn't need to tell the other party?
             self.all_addresses(),
+            self.config.stream_timeout,
+            self.config.max_concurrent_streams_per_connection,
         ))
     }
 

protocols/identify/src/handler.rs

@@ -41,9 +41,6 @@
 use std::{task::Context, task::Poll, time::Duration};
 use tracing::Level;
 
-const STREAM_TIMEOUT: Duration = Duration::from_secs(60);
-const MAX_CONCURRENT_STREAMS_PER_CONNECTION: usize = 10;
-
 /// Protocol handler for sending and receiving identification requests.
 ///
 /// Outbound requests are sent periodically. The handler performs expects
@@ -116,7 +113,7 @@
 
 impl Handler {
     /// Creates a new `Handler`.
     pub fn new(
         interval: Duration,
         remote_peer_id: PeerId,
         public_key: PublicKey,
@@ -124,13 +121,15 @@
         agent_version: String,
         observed_addr: Multiaddr,
         external_addresses: HashSet<Multiaddr>,
+        stream_timeout: Duration,
+        max_concurrent_streams_per_connection: usize,
     ) -> Self {
         Self {
             remote_peer_id,
             events: SmallVec::new(),
             active_streams: futures_bounded::FuturesSet::new(
-                STREAM_TIMEOUT,
-                MAX_CONCURRENT_STREAMS_PER_CONNECTION,
+                stream_timeout,
+                max_concurrent_streams_per_connection,
             ),
             trigger_next_identify: Delay::new(Duration::ZERO),
             exchanged_one_periodic_identify: false,