deprecate with_cache_size instead of removing it

Author: stormshield-frb

Cargo.lock

@@ -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.47.1", path = "protocols/gossipsub" }
-libp2p-identify = { version = "0.46.0", path = "protocols/identify" }
+libp2p-identify = { version = "0.45.1", 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" }

Cargo.toml

@@ -1,12 +1,10 @@
-## 0.46.0
-
-- Update to the new `PeerAddresses` API with `PeerAddressesConfig`, changing `with_cache_size` to `with_cache_config`.
-  See [PR 5574](https://github.com/libp2p/rust-libp2p/pull/5574).
-
 ## 0.45.1
 
 - Add `hide_listen_addrs` option to prevent leaking (local) listen addresses.
   See [PR 5507](https://github.com/libp2p/rust-libp2p/pull/5507).
+- Add `with_cache_config` to fully configure the identify cache using the new `PeerAddressesConfig`.
+  Deprecating `with_cache_size` in favor of the new `with_cache_config`.
+  See [PR 5574](https://github.com/libp2p/rust-libp2p/pull/5574).
 
 ## 0.45.0
 

protocols/identify/CHANGELOG.md

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

protocols/identify/Cargo.toml

@@ -34,6 +34,7 @@ use libp2p_swarm::{
 use libp2p_swarm::{ConnectionId, THandler, THandlerOutEvent};
 
 use std::collections::hash_map::Entry;
+use std::num::NonZeroUsize;
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     task::Context,
@@ -195,6 +196,23 @@ impl Config {
         self
     }
 
+    /// Configures the size of the LRU cache, caching addresses of discovered peers.
+    #[deprecated(since = "0.45.1", note = "Use `Config::with_cache_config` instead.")]
+    pub fn with_cache_size(mut self, cache_size: usize) -> Self {
+        match NonZeroUsize::new(cache_size) {
+            Some(cache_size) => {
+                if let Some(cache_config) = &mut self.cache_config {
+                    cache_config.number_of_peers = cache_size;
+                } else {
+                    self.cache_config =
+                        Some(PeerAddressesConfig::default().with_number_of_peers(cache_size))
+                }
+            }
+            None => self.cache_config = None,
+        }
+        self
+    }
+
     /// Configures whether we prevent sending out our listen addresses.
     pub fn with_hide_listen_addrs(mut self, b: bool) -> Self {
         self.hide_listen_addrs = b;

protocols/identify/src/behaviour.rs

@@ -162,10 +162,10 @@ async fn emits_unique_listen_addresses() {
             identify::Config::new("a".to_string(), identity.public())
                 .with_agent_version("b".to_string())
                 .with_interval(Duration::from_secs(1))
-                .with_cache_config(Some(PeerAddressesConfig {
-                    number_of_peers: NonZeroUsize::new(10).expect("10 != 0"),
-                    ..Default::default()
-                })),
+                .with_cache_config(Some(
+                    PeerAddressesConfig::default()
+                        .with_number_of_peers(NonZeroUsize::new(10).expect("10 != 0")),
+                )),
         )
     });
     let mut swarm2 = Swarm::new_ephemeral(|identity| {
@@ -237,7 +237,10 @@ async fn hides_listen_addresses() {
             identify::Config::new("a".to_string(), identity.public())
                 .with_agent_version("b".to_string())
                 .with_interval(Duration::from_secs(1))
-                .with_cache_size(10),
+                .with_cache_config(Some(
+                    PeerAddressesConfig::default()
+                        .with_number_of_peers(NonZeroUsize::new(10).expect("10 != 0")),
+                )),
         )
     });
     let mut swarm2 = Swarm::new_ephemeral(|identity| {

protocols/identify/tests/smoke.rs

@@ -15,14 +15,31 @@ pub struct PeerAddressesConfig {
     pub number_of_peers: NonZeroUsize,
 
     /// Maximum number of cached addresses per peer.
-    pub number_of_addresses_by_peer: NonZeroUsize,
+    pub number_of_addresses_per_peer: NonZeroUsize,
+}
+
+impl PeerAddressesConfig {
+    /// Configure the capacity of the [`PeerAddresses`] cache.
+    pub fn with_number_of_peers(mut self, number_of_peers: NonZeroUsize) -> Self {
+        self.number_of_peers = number_of_peers;
+        self
+    }
+
+    /// Configure the maximum number of cached addresses per peer.
+    pub fn with_number_of_addresses_by_peer(
+        mut self,
+        number_of_addresses_per_peer: NonZeroUsize,
+    ) -> Self {
+        self.number_of_addresses_per_peer = number_of_addresses_per_peer;
+        self
+    }
 }
 
 impl Default for PeerAddressesConfig {
     fn default() -> Self {
         Self {
             number_of_peers: NonZeroUsize::new(100).expect("100 != 0"),
-            number_of_addresses_by_peer: NonZeroUsize::new(10).expect("10 != 0"),
+            number_of_addresses_per_peer: NonZeroUsize::new(10).expect("10 != 0"),
         }
     }
 }
@@ -76,7 +93,7 @@ impl PeerAddresses {
                 if let Some(cached) = self.inner.get_mut(&peer) {
                     cached.put(address, ()).is_none()
                 } else {
-                    let mut set = LruCache::new(self.config.number_of_addresses_by_peer);
+                    let mut set = LruCache::new(self.config.number_of_addresses_per_peer);
                     set.put(address, ());
                     self.inner.put(peer, set);