chore: favor hashlink::LruCache over lru::LruCache

This PR replaces `lru::LruCache` with `hashlink::LruCache` to unify dependencies with similar functionalities. It also removes `lru` from `Cargo.lock`. (`hashlink` is also used to provide `LinkedHashMap` in `gossipsub`)

Pull-Request: #6138.

Author: hanabi1224

Cargo.lock

@@ -9,9 +9,9 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
+hashlink = { workspace = true }
 libp2p-core = { workspace = true }
 libp2p-swarm = { workspace = true }
-lru = "0.12.3"
 libp2p-identity = { workspace = true, optional = true }
 
 [dev-dependencies]

misc/peer-store/Cargo.toml

@@ -14,9 +14,9 @@ use std::{
     task::{Poll, Waker},
 };
 
+use hashlink::LruCache;
 use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::{behaviour::ConnectionEstablished, DialError, FromSwarm};
-use lru::LruCache;
 
 use super::Store;
 
@@ -317,15 +317,15 @@ pub struct PeerRecord<T> {
 impl<T> PeerRecord<T> {
     pub(crate) fn new(cap: NonZeroUsize) -> Self {
         Self {
-            addresses: LruCache::new(cap),
+            addresses: LruCache::new(cap.get()),
             custom_data: None,
         }
     }
 
     /// Iterate over all addresses. More recently-used address comes first.
     /// Does not change the order.
     pub fn addresses(&self) -> impl Iterator<Item = &Multiaddr> {
-        self.addresses.iter().map(|(addr, _)| addr)
+        self.addresses.iter().rev().map(|(addr, _)| addr)
     }
 
     /// Update the address in the LRU cache, promote it to the front if it exists,
@@ -335,14 +335,13 @@ impl<T> PeerRecord<T> {
     pub fn add_address(&mut self, address: &Multiaddr, is_permanent: bool) -> bool {
         if let Some(was_permanent) = self.addresses.get(address) {
             if !*was_permanent && is_permanent {
-                self.addresses
-                    .get_or_insert(address.clone(), || is_permanent);
+                self.addresses.insert(address.clone(), is_permanent);
             }
-            return false;
+            false
+        } else {
+            self.addresses.insert(address.clone(), is_permanent);
+            true
         }
-        self.addresses
-            .get_or_insert(address.clone(), || is_permanent);
-        true
     }
 
     /// Remove the address in the LRU cache regardless of its position.
@@ -353,7 +352,7 @@ impl<T> PeerRecord<T> {
         if !force && self.addresses.peek(address) == Some(&true) {
             return false;
         }
-        self.addresses.pop(address).is_some()
+        self.addresses.remove(address).is_some()
     }
 
     pub fn get_custom_data(&self) -> Option<&T> {
@@ -399,14 +398,14 @@ mod test {
         store.add_address(&peer, &addr1);
         store.add_address(&peer, &addr2);
         store.add_address(&peer, &addr3);
-        assert!(
+        assert_eq!(
             store
                 .records
                 .get(&peer)
                 .expect("peer to be in the store")
                 .addresses()
-                .collect::<Vec<_>>()
-                == vec![&addr3, &addr2, &addr1]
+                .collect::<Vec<_>>(),
+            vec![&addr3, &addr2, &addr1]
         );
         store.add_address(&peer, &addr1);
         assert!(

misc/peer-store/src/memory_store.rs

@@ -23,7 +23,7 @@ quick-protobuf = "0.8"
 quick-protobuf-codec = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-lru = "0.12.3"
+hashlink = { workspace = true }
 futures-bounded = { workspace = true }
 
 [dev-dependencies]

protocols/dcutr/Cargo.toml

@@ -23,11 +23,11 @@
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     convert::Infallible,
-    num::NonZeroUsize,
     task::{Context, Poll},
 };
 
 use either::Either;
+use hashlink::LruCache;
 use libp2p_core::{
     connection::ConnectedPoint, multiaddr::Protocol, transport::PortUse, Endpoint, Multiaddr,
 };
@@ -38,7 +38,6 @@ use libp2p_swarm::{
     dummy, ConnectionDenied, ConnectionHandler, ConnectionId, NetworkBehaviour,
     NewExternalAddrCandidate, NotifyHandler, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
-use lru::LruCache;
 use thiserror::Error;
 
 use crate::{handler, protocol};
@@ -361,7 +360,7 @@ struct Candidates {
 impl Candidates {
     fn new(me: PeerId) -> Self {
         Self {
-            inner: LruCache::new(NonZeroUsize::new(20).expect("20 > 0")),
+            inner: LruCache::new(20),
             me,
         }
     }
@@ -375,7 +374,7 @@ impl Candidates {
             address.push(Protocol::P2p(self.me));
         }
 
-        self.inner.push(address, ());
+        self.inner.insert(address, ());
     }
 
     fn iter(&self) -> impl Iterator<Item = &Multiaddr> {

protocols/dcutr/src/behaviour.rs

@@ -17,10 +17,10 @@ futures = { workspace = true }
 futures-timer = "3.0.3"
 getrandom = { workspace = true, features = ["js"], optional = true } # Explicit dependency to be used in `wasm-bindgen` feature
 web-time = { workspace = true }
+hashlink = { workspace = true }
 libp2p-core = { workspace = true }
 libp2p-identity = { workspace = true }
 libp2p-swarm-derive = { workspace = true, optional = true }
-lru = "0.12.3"
 multistream-select = { workspace = true }
 rand = "0.8"
 smallvec = "1.13.2"

swarm/Cargo.toml

@@ -1,8 +1,8 @@
 use std::num::NonZeroUsize;
 
+use hashlink::LruCache;
 use libp2p_core::Multiaddr;
 use libp2p_identity::PeerId;
-use lru::LruCache;
 
 use crate::{behaviour::FromSwarm, DialError, DialFailure, NewExternalAddrOfPeer};
 
@@ -15,7 +15,7 @@ impl PeerAddresses {
     ///
     /// For each peer, we will at most store 10 addresses.
     pub fn new(number_of_peers: NonZeroUsize) -> Self {
-        Self(LruCache::new(number_of_peers))
+        Self(LruCache::new(number_of_peers.get()))
     }
 
     /// Feed a [`FromSwarm`] event to this struct.
@@ -48,11 +48,11 @@ impl PeerAddresses {
         match prepare_addr(&peer, &address) {
             Ok(address) => {
                 if let Some(cached) = self.0.get_mut(&peer) {
-                    cached.put(address, ()).is_none()
+                    cached.insert(address, ()).is_none()
                 } else {
-                    let mut set = LruCache::new(NonZeroUsize::new(10).expect("10 > 0"));
-                    set.put(address, ());
-                    self.0.put(peer, set);
+                    let mut set = LruCache::new(10);
+                    set.insert(address, ());
+                    self.0.insert(peer, set);
 
                     true
                 }
@@ -75,7 +75,7 @@ impl PeerAddresses {
     pub fn remove(&mut self, peer: &PeerId, address: &Multiaddr) -> bool {
         match self.0.get_mut(peer) {
             Some(addrs) => match prepare_addr(peer, address) {
-                Ok(address) => addrs.pop(&address).is_some(),
+                Ok(address) => addrs.remove(&address).is_some(),
                 Err(_) => false,
             },
             None => false,
@@ -89,7 +89,7 @@ fn prepare_addr(peer: &PeerId, addr: &Multiaddr) -> Result<Multiaddr, Multiaddr>
 
 impl Default for PeerAddresses {
     fn default() -> Self {
-        Self(LruCache::new(NonZeroUsize::new(100).unwrap()))
+        Self(LruCache::new(100))
     }
 }