Merge branch 'master' into identity-k256

Author: dariusc93

Cargo.lock

@@ -86,20 +86,20 @@ 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-perf = { version = "0.4.0", path = "protocols/perf" }
 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

@@ -2,6 +2,9 @@
 - Introduce `libp2p-webrtc-websys` behind `webrtc-websys` feature flag.
   See [PR 5819](https://github.com/libp2p/rust-libp2p/pull/5819).
 
+- 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

@@ -99,7 +99,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 }
@@ -119,14 +118,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

@@ -123,17 +123,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

@@ -205,12 +205,12 @@
 //! ## Idle connection timeout
 //!
 //! Now, for this example in particular, we need set the idle connection timeout.
-//! Otherwise, the connection will be closed immediately.
+//! The default connection timeout is 10 seconds.
 //!
 //! Whether you need to set this in your application too depends on your usecase.
 //! Typically, connections are kept alive if they are "in use" by a certain protocol.
 //! The ping protocol however is only an "auxiliary" kind of protocol.
-//! Thus, without any other behaviour in place, we would not be able to observe the pings.
+//! Thus, without any other behaviour in place, we would not be able to observe any pings after 10s.
 //!
 //! ```rust
 //! use std::{error::Error, time::Duration};
@@ -232,6 +232,9 @@
 //!             yamux::Config::default,
 //!         )?
 //!         .with_behaviour(|_| ping::Behaviour::default())?
+//!         .with_swarm_config(|cfg| {
+//!             cfg.with_idle_connection_timeout(Duration::from_secs(u64::MAX))
+//!         }) // Allows us to observe pings indefinitely.
 //!         .build();
 //!
 //!     Ok(())
@@ -284,6 +287,9 @@
 //!             yamux::Config::default,
 //!         )?
 //!         .with_behaviour(|_| ping::Behaviour::default())?
+//!         .with_swarm_config(|cfg| {
+//!             cfg.with_idle_connection_timeout(Duration::from_secs(u64::MAX))
+//!         }) // Allows us to observe pings indefinitely.
 //!         .build();
 //!
 //!     // Tell the swarm to listen on all interfaces and a random, OS-assigned
@@ -329,6 +335,9 @@
 //!             yamux::Config::default,
 //!         )?
 //!         .with_behaviour(|_| ping::Behaviour::default())?
+//!         .with_swarm_config(|cfg| {
+//!             cfg.with_idle_connection_timeout(Duration::from_secs(u64::MAX))
+//!         }) // Allows us to observe pings indefinitely.
 //!         .build();
 //!
 //!     // Tell the swarm to listen on all interfaces and a random, OS-assigned

libp2p/src/tutorials/ping.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::{