Merge branch 'master' into peer-store

Author: drHuangMHT

Cargo.lock

@@ -87,7 +87,7 @@ libp2p-identity = { version = "0.2.10" }
 libp2p-kad = { version = "0.47.0", path = "protocols/kad" }
 libp2p-mdns = { version = "0.47.0", path = "protocols/mdns" }
 libp2p-memory-connection-limits = { version = "0.4.0", path = "misc/memory-connection-limits" }
-libp2p-metrics = { version = "0.16.0", path = "misc/metrics" }
+libp2p-metrics = { version = "0.16.1", path = "misc/metrics" }
 libp2p-mplex = { version = "0.43.1", path = "muxers/mplex" }
 libp2p-noise = { version = "0.46.0", path = "transports/noise" }
 libp2p-peer-store = { version = "0.1.0", path = "misc/peer-store" }
@@ -96,12 +96,12 @@ libp2p-ping = { version = "0.46.0", path = "protocols/ping" }
 libp2p-plaintext = { version = "0.43.0", path = "transports/plaintext" }
 libp2p-pnet = { version = "0.26.0", path = "transports/pnet" }
 libp2p-quic = { version = "0.12.0", path = "transports/quic" }
-libp2p-relay = { version = "0.19.1", path = "protocols/relay" }
+libp2p-relay = { version = "0.20.0", path = "protocols/relay" }
 libp2p-rendezvous = { version = "0.16.0", path = "protocols/rendezvous" }
 libp2p-request-response = { version = "0.28.1", path = "protocols/request-response" }
 libp2p-server = { version = "0.12.6", path = "misc/server" }
 libp2p-stream = { version = "0.3.0-alpha", path = "protocols/stream" }
-libp2p-swarm = { version = "0.46.1", path = "swarm" }
+libp2p-swarm = { version = "0.47.0", path = "swarm" }
 libp2p-swarm-derive = { version = "=0.35.1", path = "swarm-derive" } # `libp2p-swarm-derive` may not be compatible with different `libp2p-swarm` non-breaking releases. E.g. `libp2p-swarm` might introduce a new enum variant `FromSwarm` (which is `#[non-exhaustive]`) in a non-breaking release. Older versions of `libp2p-swarm-derive` would not forward this enum variant within the `NetworkBehaviour` hierarchy. Thus the version pinning is required.
 libp2p-swarm-test = { version = "0.5.0", path = "swarm-test" }
 libp2p-tcp = { version = "0.43.0", path = "transports/tcp" }

Cargo.toml

@@ -3,7 +3,7 @@
 Below is a high level roadmap for the rust-libp2p project.
 Items are ordered by priority (high to low).
 
-This is a living document.
+This is a living document. We believe the roadmap should be shaped by the needs of our user community. Many of the items below are contributions made by downstream users.
 Input is always welcome e.g. via GitHub issues or pull requests.
 
 This is the roadmap of the Rust implementation of libp2p.

ROADMAP.md

@@ -5,6 +5,9 @@
 - Introduce `libp2p-peer-store`.
   See [PR 5724](https://github.com/libp2p/rust-libp2p/pull/5724).
 
+- Make the `*-websys` variants (`libp2p-webrtc-websys`, `libp2p-websocket-websys`, `libp2p-webtransport-websys`) only available on wasm32 target architecture.
+  See [PR 5891](https://github.com/libp2p/rust-libp2p/pull/5891).
+  
 ## 0.55.0
 
 - Raise MSRV to 1.83.0.

libp2p/CHANGELOG.md

@@ -101,7 +101,6 @@ futures-timer = "3.0.2" # Explicit dependency to be used in `wasm-bindgen` featu
 getrandom = { workspace = true } # Explicit dependency to be used in `wasm-bindgen` feature
 # TODO feature flag?
 rw-stream-sink = { workspace = true }
-
 libp2p-allow-block-list = { workspace = true }
 libp2p-autonat = { workspace = true, optional = true }
 libp2p-connection-limits = { workspace = true }
@@ -122,14 +121,16 @@ libp2p-relay = { workspace = true, optional = true }
 libp2p-rendezvous = { workspace = true, optional = true }
 libp2p-request-response = { workspace = true, optional = true }
 libp2p-swarm = { workspace = true }
-libp2p-webrtc-websys = { workspace = true, optional = true }
-libp2p-websocket-websys = { workspace = true, optional = true }
-libp2p-webtransport-websys = { workspace = true, optional = true }
 libp2p-yamux = { workspace = true, optional = true }
 multiaddr = { workspace = true }
 pin-project = "1.0.0"
 thiserror = { workspace = true }
 
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+libp2p-webrtc-websys = { workspace = true, optional = true }
+libp2p-websocket-websys = { workspace = true, optional = true }
+libp2p-webtransport-websys = { workspace = true, optional = true }
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 libp2p-dns = { workspace = true, optional = true }
 libp2p-mdns = { workspace = true, optional = true }

libp2p/Cargo.toml

@@ -126,17 +126,17 @@ pub use libp2p_uds as uds;
 #[cfg(not(target_arch = "wasm32"))]
 #[doc(inline)]
 pub use libp2p_upnp as upnp;
-#[cfg(feature = "webrtc-websys")]
+#[cfg(all(feature = "webrtc-websys", target_arch = "wasm32"))]
 #[doc(inline)]
 pub use libp2p_webrtc_websys as webrtc_websys;
 #[cfg(feature = "websocket")]
 #[cfg(not(target_arch = "wasm32"))]
 #[doc(inline)]
 pub use libp2p_websocket as websocket;
-#[cfg(feature = "websocket-websys")]
+#[cfg(all(feature = "websocket-websys", target_arch = "wasm32"))]
 #[doc(inline)]
 pub use libp2p_websocket_websys as websocket_websys;
-#[cfg(feature = "webtransport-websys")]
+#[cfg(all(feature = "webtransport-websys", target_arch = "wasm32"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "webtransport-websys")))]
 #[doc(inline)]
 pub use libp2p_webtransport_websys as webtransport_websys;

libp2p/src/lib.rs

@@ -1,3 +1,7 @@
+## 0.16.1
+- Add `ReservationClosed` as a relay metric.
+  See [PR 5869](https://github.com/libp2p/rust-libp2p/pull/5869).
+
 ## 0.16.0
 
 <!-- Update to libp2p-core v0.43.0 -->

misc/metrics/CHANGELOG.md

@@ -3,7 +3,7 @@ name = "libp2p-metrics"
 edition = "2021"
 rust-version = { workspace = true }
 description = "Metrics for libp2p"
-version = "0.16.0"
+version = "0.16.1"
 authors = ["Max Inden <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

misc/metrics/Cargo.toml

@@ -54,6 +54,7 @@ enum EventType {
     ReservationReqAcceptFailed,
     ReservationReqDenied,
     ReservationReqDenyFailed,
+    ReservationClosed,
     ReservationTimedOut,
     CircuitReqDenied,
     CircuitReqDenyFailed,
@@ -76,6 +77,7 @@ impl From<&libp2p_relay::Event> for EventType {
             libp2p_relay::Event::ReservationReqDenyFailed { .. } => {
                 EventType::ReservationReqDenyFailed
             }
+            libp2p_relay::Event::ReservationClosed { .. } => EventType::ReservationClosed,
             libp2p_relay::Event::ReservationTimedOut { .. } => EventType::ReservationTimedOut,
             libp2p_relay::Event::CircuitReqDenied { .. } => EventType::CircuitReqDenied,
             #[allow(deprecated)]

misc/metrics/src/relay.rs

@@ -1,4 +1,7 @@
 ## 0.48.1
+- Allow whitelisting topics for metrics to ensure metrics are recorded correctly for these topics.
+  See [PR 5895](https://github.com/libp2p/rust-libp2p/pull/5895)
+
 - Improve `max_messages_per_rpc` consistency by ensuring RPC control messages also adhere to the existing limits.
   See [PR 5826](https://github.com/libp2p/rust-libp2p/pull/5826)
 

protocols/gossipsub/CHANGELOG.md

@@ -3053,6 +3053,13 @@ where
             }
         }
     }
+
+    /// Register topics to ensure metrics are recorded correctly for these topics.
+    pub fn register_topics_for_metrics(&mut self, topics: Vec<TopicHash>) {
+        if let Some(metrics) = &mut self.metrics {
+            metrics.register_allowed_topics(topics);
+        }
+    }
 }
 
 fn get_ip_addr(addr: &Multiaddr) -> Option<IpAddr> {

protocols/gossipsub/src/behaviour.rs

@@ -648,6 +648,13 @@ impl Metrics {
             metric.set(metric.get() - 1);
         }
     }
+
+    /// Registers a set of topics that we want to store calculate metrics for.
+    pub(crate) fn register_allowed_topics(&mut self, topics: Vec<TopicHash>) {
+        for topic_hash in topics {
+            self.topic_info.insert(topic_hash, true);
+        }
+    }
 }
 
 /// Reasons why a peer was included in the mesh.

protocols/gossipsub/src/metrics.rs

@@ -1,6 +1,8 @@
-## 0.19.1
+## 0.20.0
 
 - Remove duplicated forwarding of pending events to connection handler.
+- Emit `relay::Event::ReservationClosed` when an active reservation is dropped due to the connection closing.
+  See [PR 5869](https://github.com/libp2p/rust-libp2p/pull/5869).
 
 ## 0.19.0
 

protocols/relay/CHANGELOG.md

@@ -3,7 +3,7 @@ name = "libp2p-relay"
 edition = "2021"
 rust-version = { workspace = true }
 description = "Communications relaying for libp2p"
-version = "0.19.1"
+version = "0.20.0"
 authors = ["Parity Technologies <[email protected]>", "Max Inden <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

protocols/relay/Cargo.toml

@@ -193,6 +193,8 @@ pub enum Event {
         src_peer_id: PeerId,
         error: inbound_hop::Error,
     },
+    /// A reservation has been closed.
+    ReservationClosed { src_peer_id: PeerId },
     /// An inbound reservation has timed out.
     ReservationTimedOut { src_peer_id: PeerId },
     /// An inbound circuit request has been denied.
@@ -277,7 +279,12 @@ impl Behaviour {
         }: ConnectionClosed,
     ) {
         if let hash_map::Entry::Occupied(mut peer) = self.reservations.entry(peer_id) {
-            peer.get_mut().remove(&connection_id);
+            if peer.get_mut().remove(&connection_id) {
+                self.queued_actions
+                    .push_back(ToSwarm::GenerateEvent(Event::ReservationClosed {
+                        src_peer_id: peer_id,
+                    }));
+            }
             if peer.get().is_empty() {
                 peer.remove();
             }

protocols/relay/src/behaviour.rs

@@ -264,12 +264,10 @@ impl NetworkBehaviour for Behaviour {
                 listener_id,
                 addr: multiaddr,
             }) => {
-                let (addr, protocol) = match multiaddr_to_socketaddr_protocol(multiaddr.clone()) {
-                    Ok(addr_port) => addr_port,
-                    Err(()) => {
-                        tracing::debug!("multiaddress not supported for UPnP {multiaddr}");
-                        return;
-                    }
+                let Ok((addr, protocol)) = multiaddr_to_socketaddr_protocol(multiaddr.clone())
+                else {
+                    tracing::debug!("multiaddress not supported for UPnP {multiaddr}");
+                    return;
                 };
 
                 if let Some((mapping, _state)) = self

protocols/upnp/src/behaviour.rs

@@ -10,7 +10,7 @@ MERGE_BASE=$(git merge-base "$HEAD_SHA" "$PR_BASE") # Find the merge base. This
 SRC_DIFF_TO_BASE=$(git diff "$HEAD_SHA".."$MERGE_BASE" --name-status -- "$DIR_TO_CRATE/src" "$DIR_TO_CRATE/Cargo.toml")
 CHANGELOG_DIFF=$(git diff "$HEAD_SHA".."$MERGE_BASE" --name-only -- "$DIR_TO_CRATE/CHANGELOG.md")
 
-RELEASED_VERSION=$(git tag --sort=version:refname | grep "^$CRATE-v" | tail -n1 | grep -Po "\d+\.\d+\.\d+")
+RELEASED_VERSION=$(git tag --sort=version:refname | grep "^$CRATE-v" | tail -n1 | grep -Po "\d+\.\d+\.\d+(-.+)?")
 
 
 # If the source files of this crate weren't touched in this PR, exit early.

scripts/ensure-version-bump-and-changelog.sh

@@ -1,4 +1,6 @@
-## 0.46.1
+## 0.47.0
+- Separate the `PendingConnectionError` into two parts `PendingOutboundConnectionError` and `PendingInboundConnectionError` to have better control over error handling. See [PR](https://github.com/libp2p/rust-libp2p/pull/5861)
+
 - Undo `ConnectionHandler::{InboundOpenInfo, OutboundOpenInfo}` deprecation.
   Substreams are not completely interchangeable and a certain Substream may be associated with a
   certain upgrade.

swarm/CHANGELOG.md

@@ -3,7 +3,7 @@ name = "libp2p-swarm"
 edition = "2021"
 rust-version = { workspace = true }
 description = "The libp2p swarm"
-version = "0.46.1"
+version = "0.47.0"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

swarm/Cargo.toml

@@ -36,9 +36,7 @@ use std::{
 };
 
 pub use error::ConnectionError;
-pub(crate) use error::{
-    PendingConnectionError, PendingInboundConnectionError, PendingOutboundConnectionError,
-};
+pub(crate) use error::{PendingInboundConnectionError, PendingOutboundConnectionError};
 use futures::{future::BoxFuture, stream, stream::FuturesUnordered, FutureExt, StreamExt};
 use futures_timer::Delay;
 use libp2p_core::{

swarm/src/connection.rs

@@ -20,7 +20,7 @@
 
 use std::{fmt, io};
 
-use crate::{transport::TransportError, ConnectedPoint, Multiaddr, PeerId};
+use crate::{transport::TransportError, Multiaddr, PeerId};
 
 /// Errors that can occur in the context of an established `Connection`.
 #[derive(Debug)]
@@ -64,17 +64,10 @@ impl From<io::Error> for ConnectionError {
 /// Note: Addresses for an outbound connection are dialed in parallel. Thus, compared to
 /// [`PendingInboundConnectionError`], one or more [`TransportError`]s can occur for a single
 /// connection.
-pub(crate) type PendingOutboundConnectionError =
-    PendingConnectionError<Vec<(Multiaddr, TransportError<io::Error>)>>;
-
-/// Errors that can occur in the context of a pending incoming `Connection`.
-pub(crate) type PendingInboundConnectionError = PendingConnectionError<TransportError<io::Error>>;
-
-/// Errors that can occur in the context of a pending `Connection`.
 #[derive(Debug)]
-pub enum PendingConnectionError<TTransErr> {
+pub(crate) enum PendingOutboundConnectionError {
     /// An error occurred while negotiating the transport protocol(s) on a connection.
-    Transport(TTransErr),
+    Transport(Vec<(Multiaddr, TransportError<io::Error>)>),
 
     /// Pending connection attempt has been aborted.
     Aborted,
@@ -83,64 +76,22 @@ pub enum PendingConnectionError<TTransErr> {
     /// match the one that was expected.
     WrongPeerId {
         obtained: PeerId,
-        endpoint: ConnectedPoint,
+        address: Multiaddr,
     },
 
     /// The connection was dropped because it resolved to our own [`PeerId`].
-    LocalPeerId { endpoint: ConnectedPoint },
+    LocalPeerId { address: Multiaddr },
 }
 
-impl<T> PendingConnectionError<T> {
-    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> PendingConnectionError<U> {
-        match self {
-            PendingConnectionError::Transport(t) => PendingConnectionError::Transport(f(t)),
-            PendingConnectionError::Aborted => PendingConnectionError::Aborted,
-            PendingConnectionError::WrongPeerId { obtained, endpoint } => {
-                PendingConnectionError::WrongPeerId { obtained, endpoint }
-            }
-            PendingConnectionError::LocalPeerId { endpoint } => {
-                PendingConnectionError::LocalPeerId { endpoint }
-            }
-        }
-    }
-}
+/// Errors that can occur in the context of a pending incoming `Connection`.
+#[derive(Debug)]
+pub(crate) enum PendingInboundConnectionError {
+    /// An error occurred while negotiating the transport protocol(s) on a connection.
+    Transport(TransportError<io::Error>),
 
-impl<TTransErr> fmt::Display for PendingConnectionError<TTransErr>
-where
-    TTransErr: fmt::Display + fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            PendingConnectionError::Aborted => write!(f, "Pending connection: Aborted."),
-            PendingConnectionError::Transport(err) => {
-                write!(
-                    f,
-                    "Pending connection: Transport error on connection: {err}"
-                )
-            }
-            PendingConnectionError::WrongPeerId { obtained, endpoint } => {
-                write!(
-                    f,
-                    "Pending connection: Unexpected peer ID {obtained} at {endpoint:?}."
-                )
-            }
-            PendingConnectionError::LocalPeerId { endpoint } => {
-                write!(f, "Pending connection: Local peer ID at {endpoint:?}.")
-            }
-        }
-    }
-}
+    /// Pending connection attempt has been aborted.
+    Aborted,
 
-impl<TTransErr> std::error::Error for PendingConnectionError<TTransErr>
-where
-    TTransErr: std::error::Error + 'static,
-{
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            PendingConnectionError::Transport(_) => None,
-            PendingConnectionError::WrongPeerId { .. } => None,
-            PendingConnectionError::LocalPeerId { .. } => None,
-            PendingConnectionError::Aborted => None,
-        }
-    }
+    /// The connection was dropped because it resolved to our own [`PeerId`].
+    LocalPeerId { address: Multiaddr },
 }