Merge branch 'master' into 2824-remove-into-connection-handler

Author: thomaseizinger

CHANGELOG.md

@@ -45,13 +45,20 @@
 
 # `libp2p` facade crate
 
-# 0.50.0 - [unreleased]
+# 0.50.0
+
+This is a large release. After > 4 years, rust-libp2p ships with an [(alpha) QUIC
+implementation](transports/quic/CHANGELOG.md#070-alpha). The [necessary TLS logic is extracted into
+its own crate](transports/tls/CHANGELOG.md#010-alpha), and can thus be used detached from QUIC, e.g.
+on top of TCP as an alternative to Noise. In addition to these two transports, this release adds
+a third, namely [WebRTC (browser-to-server)](transports/webrtc/CHANGELOG.md#040-alpha). But that is
+definitely not it. See below for the many other changes packed into this release.
 
 - Introduce [`libp2p-tls` `v0.1.0-alpha`](transports/tls/CHANGELOG.md#010-alpha). See [PR 2945].
 - Introduce [`libp2p-quic` `v0.7.0-alpha`](transports/quic/CHANGELOG.md#070-alpha). See [PR 2289].
+- Introduce [`libp2p-webrtc` `v0.4.0-alpha`](transports/webrtc/CHANGELOG.md#040-alpha). See [PR 2289].
 - Remove deprecated features: `tcp-tokio`, `mdns-tokio`, `dns-tokio`, `tcp-async-io`, `mdns-async-io`, `dns-async-std`.
   See [PR 3001].
-- Introduce [`libp2p-tls` `v0.1.0`](transports/tls/CHANGELOG.md#010). See [PR 2945].
 - Remove `NetworkBehaviour` macro export from root crate in favor of re-exported macro from `libp2p::swarm`.
   Change your import from `libp2p::NetworkBehaviour` to `libp2p::swarm::NetworkBehaviour`. See [PR 3055].
 - Feature-gate `NetworkBehaviour` macro behind `macros` feature flag. See [PR 3055].
@@ -100,7 +107,7 @@
   - `tcp-async-io` in favor of `tcp` + `async-std`
   - `mdns-async-io` in favor of `mdns` + `async-std`
   - `dns-async-std` in favor of `dns` + `async-std`
-  
+
   See [PR 2962].
 
 - Update individual crates.

Cargo.toml

@@ -78,7 +78,7 @@ serde = ["libp2p-core/serde", "libp2p-kad?/serde", "libp2p-gossipsub?/serde"]
 tcp = ["dep:libp2p-tcp"]
 tokio = ["libp2p-swarm/tokio", "libp2p-mdns?/tokio", "libp2p-tcp?/tokio", "libp2p-dns?/tokio", "libp2p-quic?/tokio", "libp2p-webrtc?/tokio"]
 uds = ["dep:libp2p-uds"]
-wasm-bindgen = ["futures-timer/wasm-bindgen", "instant/wasm-bindgen", "getrandom/js"]
+wasm-bindgen = ["futures-timer/wasm-bindgen", "instant/wasm-bindgen", "getrandom/js", "libp2p-swarm/wasm-bindgen"]
 wasm-ext = ["dep:libp2p-wasm-ext"]
 wasm-ext-websocket = ["wasm-ext", "libp2p-wasm-ext?/websocket"]
 webrtc = ["dep:libp2p-webrtc", "libp2p-webrtc?/pem"]
@@ -123,7 +123,7 @@ libp2p-mdns = { version = "0.42.0", path = "protocols/mdns", optional = true }
 libp2p-quic = { version = "0.7.0-alpha", path = "transports/quic", optional = true }
 libp2p-tcp = { version = "0.38.0", path = "transports/tcp", optional = true }
 libp2p-tls = { version = "0.1.0-alpha", path = "transports/tls", optional = true }
-libp2p-webrtc = { version = "0.1.0-alpha", path = "transports/webrtc", optional = true }
+libp2p-webrtc = { version = "0.4.0-alpha", path = "transports/webrtc", optional = true }
 libp2p-websocket = { version = "0.40.0", path = "transports/websocket", optional = true }
 
 [target.'cfg(not(target_os = "unknown"))'.dependencies]

core/CHANGELOG.md

@@ -1,4 +1,4 @@
-# 0.38.0 [unreleased]
+# 0.38.0
 
 - Remove deprecated functions `StreamMuxerExt::next_{inbound,outbound}`. See [PR 3031].
 

examples/distributed-key-value-store.rs

@@ -52,6 +52,7 @@ use libp2p::{
     swarm::{NetworkBehaviour, SwarmEvent},
     PeerId, Swarm,
 };
+use libp2p_kad::{GetProvidersOk, GetRecordOk};
 use std::error::Error;
 
 #[async_std::main]
@@ -120,33 +121,32 @@ async fn main() -> Result<(), Box<dyn Error>> {
                     swarm.behaviour_mut().kademlia.add_address(&peer_id, multiaddr);
                 }
             }
-            SwarmEvent::Behaviour(MyBehaviourEvent::Kademlia(KademliaEvent::OutboundQueryCompleted { result, ..})) => {
+            SwarmEvent::Behaviour(MyBehaviourEvent::Kademlia(KademliaEvent::OutboundQueryProgressed { result, ..})) => {
                 match result {
-                    QueryResult::GetProviders(Ok(ok)) => {
-                        for peer in ok.providers {
+                    QueryResult::GetProviders(Ok(GetProvidersOk::FoundProviders { key, providers, .. })) => {
+                        for peer in providers {
                             println!(
-                                "Peer {:?} provides key {:?}",
-                                peer,
-                                std::str::from_utf8(ok.key.as_ref()).unwrap()
+                                "Peer {peer:?} provides key {:?}",
+                                std::str::from_utf8(key.as_ref()).unwrap()
                             );
                         }
                     }
                     QueryResult::GetProviders(Err(err)) => {
                         eprintln!("Failed to get providers: {err:?}");
                     }
-                    QueryResult::GetRecord(Ok(ok)) => {
-                        for PeerRecord {
+                    QueryResult::GetRecord(Ok(
+                        GetRecordOk::FoundRecord(PeerRecord {
                             record: Record { key, value, .. },
                             ..
-                        } in ok.records
-                        {
-                            println!(
-                                "Got record {:?} {:?}",
-                                std::str::from_utf8(key.as_ref()).unwrap(),
-                                std::str::from_utf8(&value).unwrap(),
-                            );
-                        }
+                        })
+                    )) => {
+                        println!(
+                            "Got record {:?} {:?}",
+                            std::str::from_utf8(key.as_ref()).unwrap(),
+                            std::str::from_utf8(&value).unwrap(),
+                        );
                     }
+                    QueryResult::GetRecord(Ok(_)) => {}
                     QueryResult::GetRecord(Err(err)) => {
                         eprintln!("Failed to get record: {err:?}");
                     }
@@ -191,7 +191,7 @@ fn handle_input_line(kademlia: &mut Kademlia<MemoryStore>, line: String) {
                     }
                 }
             };
-            kademlia.get_record(key, Quorum::One);
+            kademlia.get_record(key);
         }
         Some("GET_PROVIDERS") => {
             let key = {

examples/file-sharing.rs

@@ -414,7 +414,7 @@ mod network {
         ) {
             match event {
                 SwarmEvent::Behaviour(ComposedEvent::Kademlia(
-                    KademliaEvent::OutboundQueryCompleted {
+                    KademliaEvent::OutboundQueryProgressed {
                         id,
                         result: QueryResult::StartProviding(_),
                         ..
@@ -427,18 +427,37 @@ mod network {
                     let _ = sender.send(());
                 }
                 SwarmEvent::Behaviour(ComposedEvent::Kademlia(
-                    KademliaEvent::OutboundQueryCompleted {
+                    KademliaEvent::OutboundQueryProgressed {
                         id,
-                        result: QueryResult::GetProviders(Ok(GetProvidersOk { providers, .. })),
+                        result:
+                            QueryResult::GetProviders(Ok(GetProvidersOk::FoundProviders {
+                                providers,
+                                ..
+                            })),
                         ..
                     },
                 )) => {
-                    let _ = self
-                        .pending_get_providers
-                        .remove(&id)
-                        .expect("Completed query to be previously pending.")
-                        .send(providers);
+                    if let Some(sender) = self.pending_get_providers.remove(&id) {
+                        sender.send(providers).expect("Receiver not to be dropped");
+
+                        // Finish the query. We are only interested in the first result.
+                        self.swarm
+                            .behaviour_mut()
+                            .kademlia
+                            .query_mut(&id)
+                            .unwrap()
+                            .finish();
+                    }
                 }
+                SwarmEvent::Behaviour(ComposedEvent::Kademlia(
+                    KademliaEvent::OutboundQueryProgressed {
+                        result:
+                            QueryResult::GetProviders(Ok(
+                                GetProvidersOk::FinishedWithNoAdditionalRecord { .. },
+                            )),
+                        ..
+                    },
+                )) => {}
                 SwarmEvent::Behaviour(ComposedEvent::Kademlia(_)) => {}
                 SwarmEvent::Behaviour(ComposedEvent::RequestResponse(
                     RequestResponseEvent::Message { message, .. },

examples/ipfs-kad.rs

@@ -81,7 +81,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     loop {
         let event = swarm.select_next_some().await;
-        if let SwarmEvent::Behaviour(KademliaEvent::OutboundQueryCompleted {
+        if let SwarmEvent::Behaviour(KademliaEvent::OutboundQueryProgressed {
             result: QueryResult::GetClosestPeers(result),
             ..
         }) = event

misc/metrics/CHANGELOG.md

@@ -1,4 +1,4 @@
-# 0.11.0 [unreleased]
+# 0.11.0
 
 - Update to `libp2p-dcutr` `v0.8.0`.
 
@@ -20,8 +20,12 @@
 
 - Update `rust-version` to reflect the actual MSRV: 1.62.0. See [PR 3090].
 
+- Changed `Metrics::query_result_get_record_ok` from `Histogram` to a `Counter`.
+  See [PR 2712].
+
 [PR 2982]: https://github.com/libp2p/rust-libp2p/pull/2982/
 [PR 3090]: https://github.com/libp2p/rust-libp2p/pull/3090
+[PR 2712]: https://github.com/libp2p/rust-libp2p/pull/2712
 
 # 0.10.0
 

misc/metrics/src/kad.rs

@@ -25,7 +25,7 @@ use prometheus_client::metrics::histogram::{exponential_buckets, Histogram};
 use prometheus_client::registry::{Registry, Unit};
 
 pub struct Metrics {
-    query_result_get_record_ok: Histogram,
+    query_result_get_record_ok: Counter,
     query_result_get_record_error: Family<GetRecordResult, Counter>,
 
     query_result_get_closest_peers_ok: Histogram,
@@ -48,7 +48,7 @@ impl Metrics {
     pub fn new(registry: &mut Registry) -> Self {
         let sub_registry = registry.sub_registry_with_prefix("kad");
 
-        let query_result_get_record_ok = Histogram::new(exponential_buckets(1.0, 2.0, 10));
+        let query_result_get_record_ok = Counter::default();
         sub_registry.register(
             "query_result_get_record_ok",
             "Number of records returned by a successful Kademlia get record query.",
@@ -162,7 +162,7 @@ impl Metrics {
 impl super::Recorder<libp2p_kad::KademliaEvent> for Metrics {
     fn record(&self, event: &libp2p_kad::KademliaEvent) {
         match event {
-            libp2p_kad::KademliaEvent::OutboundQueryCompleted { result, stats, .. } => {
+            libp2p_kad::KademliaEvent::OutboundQueryProgressed { result, stats, .. } => {
                 self.query_result_num_requests
                     .get_or_create(&result.into())
                     .observe(stats.num_requests().into());
@@ -180,9 +180,10 @@ impl super::Recorder<libp2p_kad::KademliaEvent> for Metrics {
 
                 match result {
                     libp2p_kad::QueryResult::GetRecord(result) => match result {
-                        Ok(ok) => self
-                            .query_result_get_record_ok
-                            .observe(ok.records.len() as f64),
+                        Ok(libp2p_kad::GetRecordOk::FoundRecord(_)) => {
+                            self.query_result_get_record_ok.inc();
+                        }
+                        Ok(libp2p_kad::GetRecordOk::FinishedWithNoAdditionalRecord { .. }) => {}
                         Err(error) => {
                             self.query_result_get_record_error
                                 .get_or_create(&error.into())
@@ -200,9 +201,13 @@ impl super::Recorder<libp2p_kad::KademliaEvent> for Metrics {
                         }
                     },
                     libp2p_kad::QueryResult::GetProviders(result) => match result {
-                        Ok(ok) => self
-                            .query_result_get_providers_ok
-                            .observe(ok.providers.len() as f64),
+                        Ok(libp2p_kad::GetProvidersOk::FoundProviders { providers, .. }) => {
+                            self.query_result_get_providers_ok
+                                .observe(providers.len() as f64);
+                        }
+                        Ok(libp2p_kad::GetProvidersOk::FinishedWithNoAdditionalRecord {
+                            ..
+                        }) => {}
                         Err(error) => {
                             self.query_result_get_providers_error
                                 .get_or_create(&error.into())

misc/prost-codec/CHANGELOG.md

@@ -1,5 +1,4 @@
-
-# 0.3.0 [unreleased]
+# 0.3.0
 
 - Implement `From` trait for `std::io::Error`. See [PR 2622].
 - Don't leak `prost` dependency in `Error` type. See [PR 3058].

muxers/mplex/CHANGELOG.md

@@ -1,4 +1,4 @@
-# 0.38.0 [unreleased]
+# 0.38.0
 
 - Update to `libp2p-core` `v0.38.0`.