feat: remove async_std support in QUIC crate

Pull-Request: #5954.

Author: gitToki

Cargo.lock

@@ -96,7 +96,7 @@ 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.1", path = "transports/quic" }
+libp2p-quic = { version = "0.13.0", path = "transports/quic" }
 libp2p-relay = { version = "0.20.0", path = "protocols/relay" }
 libp2p-rendezvous = { version = "0.16.1", path = "protocols/rendezvous" }
 libp2p-request-response = { version = "0.28.1", path = "protocols/request-response" }

Cargo.toml

@@ -12,6 +12,9 @@
 
 - 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).
+
+- Remove QUIC from the `async-std` swarm builder, as `async-std` support was removed from `libp2p-quic` transport.
+  See [PR 5954](https://github.com/libp2p/rust-libp2p/pull/5954)
 
 ## 0.55.0
 

libp2p/CHANGELOG.md

@@ -53,7 +53,7 @@ full = [
     "upnp",
 ]
 
-async-std = [ "libp2p-swarm/async-std", "libp2p-tcp?/async-io", "libp2p-dns?/async-std", "libp2p-quic?/async-std",]
+async-std = ["libp2p-swarm/async-std", "libp2p-tcp?/async-io", "libp2p-dns?/async-std"]
 autonat = ["dep:libp2p-autonat"]
 cbor = ["libp2p-request-response?/cbor"]
 dcutr = ["dep:libp2p-dcutr", "libp2p-metrics?/dcutr"]
@@ -83,9 +83,9 @@ secp256k1 = ["libp2p-identity/secp256k1"]
 serde = ["libp2p-core/serde", "libp2p-kad?/serde", "libp2p-gossipsub?/serde"]
 tcp = ["dep:libp2p-tcp"]
 tls = ["dep:libp2p-tls"]
-tokio = [ "libp2p-swarm/tokio", "libp2p-mdns?/tokio", "libp2p-tcp?/tokio", "libp2p-dns?/tokio", "libp2p-quic?/tokio", "libp2p-upnp?/tokio"]
+tokio = ["libp2p-swarm/tokio", "libp2p-mdns?/tokio", "libp2p-tcp?/tokio", "libp2p-dns?/tokio", "libp2p-quic?/tokio", "libp2p-upnp?/tokio"]
 uds = ["dep:libp2p-uds"]
-wasm-bindgen = [ "futures-timer/wasm-bindgen", "getrandom/js", "libp2p-swarm/wasm-bindgen", "libp2p-gossipsub?/wasm-bindgen"]
+wasm-bindgen = ["futures-timer/wasm-bindgen", "getrandom/js", "libp2p-swarm/wasm-bindgen", "libp2p-gossipsub?/wasm-bindgen"]
 webrtc-websys = ['dep:libp2p-webrtc-websys']
 websocket-websys = ["dep:libp2p-websocket-websys"]
 websocket = ["dep:libp2p-websocket"]
@@ -144,7 +144,7 @@ libp2p-websocket = { workspace = true, optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.6.2", features = ["attributes"] }
-tokio = { workspace = true, features = [ "io-util", "io-std", "macros", "rt", "rt-multi-thread"] }
+tokio = { workspace = true, features = ["io-util", "io-std", "macros", "rt", "rt-multi-thread"] }
 
 libp2p-mplex = { workspace = true }
 libp2p-tcp = { workspace = true, features = ["tokio"] }

libp2p/Cargo.toml

@@ -135,17 +135,6 @@ mod tests {
             .build();
     }
 
-    #[test]
-    #[cfg(all(feature = "async-std", feature = "quic"))]
-    fn async_std_quic() {
-        let _ = SwarmBuilder::with_new_identity()
-            .with_async_std()
-            .with_quic()
-            .with_behaviour(|_| libp2p_swarm::dummy::Behaviour)
-            .unwrap()
-            .build();
-    }
-
     #[test]
     #[cfg(all(feature = "tokio", feature = "quic"))]
     fn quic_config() {
@@ -157,17 +146,6 @@ mod tests {
             .build();
     }
 
-    #[test]
-    #[cfg(all(feature = "async-std", feature = "quic"))]
-    fn async_std_quic_config() {
-        let _ = SwarmBuilder::with_new_identity()
-            .with_async_std()
-            .with_quic_config(|config| config)
-            .with_behaviour(|_| libp2p_swarm::dummy::Behaviour)
-            .unwrap()
-            .build();
-    }
-
     #[test]
     #[cfg(all(feature = "tokio", feature = "tcp", feature = "tls", feature = "yamux"))]
     fn tcp_yamux_mplex() {
@@ -230,30 +208,6 @@ mod tests {
             .build();
     }
 
-    #[test]
-    #[cfg(all(
-        feature = "async-std",
-        feature = "tcp",
-        feature = "tls",
-        feature = "noise",
-        feature = "yamux",
-        feature = "quic"
-    ))]
-    fn async_std_tcp_quic() {
-        let _ = SwarmBuilder::with_new_identity()
-            .with_async_std()
-            .with_tcp(
-                Default::default(),
-                (libp2p_tls::Config::new, libp2p_noise::Config::new),
-                libp2p_yamux::Config::default,
-            )
-            .unwrap()
-            .with_quic()
-            .with_behaviour(|_| libp2p_swarm::dummy::Behaviour)
-            .unwrap()
-            .build();
-    }
-
     #[test]
     #[cfg(all(
         feature = "tokio",
@@ -278,30 +232,6 @@ mod tests {
             .build();
     }
 
-    #[test]
-    #[cfg(all(
-        feature = "async-std",
-        feature = "tcp",
-        feature = "tls",
-        feature = "noise",
-        feature = "yamux",
-        feature = "quic"
-    ))]
-    fn async_std_tcp_quic_config() {
-        let _ = SwarmBuilder::with_new_identity()
-            .with_async_std()
-            .with_tcp(
-                Default::default(),
-                (libp2p_tls::Config::new, libp2p_noise::Config::new),
-                libp2p_yamux::Config::default,
-            )
-            .unwrap()
-            .with_quic_config(|config| config)
-            .with_behaviour(|_| libp2p_swarm::dummy::Behaviour)
-            .unwrap()
-            .build();
-    }
-
     #[test]
     #[cfg(all(
         feature = "tokio",
@@ -431,34 +361,6 @@ mod tests {
             .build();
     }
 
-    #[tokio::test]
-    #[cfg(all(
-        feature = "async-std",
-        feature = "tcp",
-        feature = "noise",
-        feature = "yamux",
-        feature = "quic",
-        feature = "dns"
-    ))]
-    async fn async_std_tcp_quic_dns_config() {
-        SwarmBuilder::with_new_identity()
-            .with_async_std()
-            .with_tcp(
-                Default::default(),
-                (libp2p_tls::Config::new, libp2p_noise::Config::new),
-                libp2p_yamux::Config::default,
-            )
-            .unwrap()
-            .with_quic()
-            .with_dns_config(
-                libp2p_dns::ResolverConfig::default(),
-                libp2p_dns::ResolverOpts::default(),
-            )
-            .with_behaviour(|_| libp2p_swarm::dummy::Behaviour)
-            .unwrap()
-            .build();
-    }
-
     /// Showcases how to provide custom transports unknown to the libp2p crate, e.g. WebRTC.
     #[test]
     #[cfg(feature = "tokio")]

libp2p/src/builder.rs

@@ -59,7 +59,6 @@ macro_rules! impl_quic_builder {
     };
 }
 
-impl_quic_builder!("async-std", AsyncStd, async_std);
 impl_quic_builder!("tokio", super::provider::Tokio, tokio);
 
 impl<Provider, T> SwarmBuilder<Provider, QuicPhase<T>> {

libp2p/src/builder/phase/quic.rs

@@ -114,18 +114,6 @@ impl<Provider> SwarmBuilder<Provider, TcpPhase> {
     }
 }
 
-// Shortcuts
-#[cfg(all(not(target_arch = "wasm32"), feature = "quic", feature = "async-std"))]
-impl SwarmBuilder<super::provider::AsyncStd, TcpPhase> {
-    pub fn with_quic(
-        self,
-    ) -> SwarmBuilder<
-        super::provider::AsyncStd,
-        OtherTransportPhase<impl AuthenticatedMultiplexedTransport>,
-    > {
-        self.without_tcp().with_quic()
-    }
-}
 #[cfg(all(not(target_arch = "wasm32"), feature = "quic", feature = "tokio"))]
 impl SwarmBuilder<super::provider::Tokio, TcpPhase> {
     pub fn with_quic(
@@ -137,18 +125,6 @@ impl SwarmBuilder<super::provider::Tokio, TcpPhase> {
         self.without_tcp().with_quic()
     }
 }
-#[cfg(all(not(target_arch = "wasm32"), feature = "quic", feature = "async-std"))]
-impl SwarmBuilder<super::provider::AsyncStd, TcpPhase> {
-    pub fn with_quic_config(
-        self,
-        constructor: impl FnOnce(libp2p_quic::Config) -> libp2p_quic::Config,
-    ) -> SwarmBuilder<
-        super::provider::AsyncStd,
-        OtherTransportPhase<impl AuthenticatedMultiplexedTransport>,
-    > {
-        self.without_tcp().with_quic_config(constructor)
-    }
-}
 #[cfg(all(not(target_arch = "wasm32"), feature = "quic", feature = "tokio"))]
 impl SwarmBuilder<super::provider::Tokio, TcpPhase> {
     pub fn with_quic_config(

libp2p/src/builder/phase/tcp.rs

@@ -1,4 +1,7 @@
-## 0.12.1
+## 0.13.0
+
+- Remove `async-std` support.
+  See [PR 5954](https://github.com/libp2p/rust-libp2p/pull/5954)
 
 - Deprecate `Config::support_draft_29`.
   See [PR 5786](https://github.com/libp2p/rust-libp2p/pull/5786).

transports/quic/CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "libp2p-quic"
-version = "0.12.1"
+version = "0.13.0"
 authors = ["Parity Technologies <[email protected]>"]
 edition.workspace = true
 rust-version = { workspace = true }
@@ -9,7 +9,6 @@ repository = "https://github.com/libp2p/rust-libp2p"
 license = "MIT"
 
 [dependencies]
-async-std = { version = "1.12.0", optional = true }
 futures = { workspace = true }
 futures-timer = "3.0.3"
 if-watch = { workspace = true }
@@ -27,7 +26,6 @@ ring = { workspace = true }
 
 [features]
 tokio = ["dep:tokio", "if-watch/tokio", "quinn/runtime-tokio"]
-async-std = ["dep:async-std", "if-watch/smol", "quinn/runtime-async-std"]
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.
 # More information: https://docs.rs/about/builds#cross-compiling

transports/quic/Cargo.toml

@@ -25,26 +25,26 @@
 //! Example:
 //!
 //! ```
-//! # #[cfg(not(feature = "async-std"))]
+//! # #[cfg(not(feature = "tokio"))]
 //! # fn main() {}
 //! #
-//! # #[cfg(feature = "async-std")]
-//! # fn main() -> std::io::Result<()> {
+//! # #[cfg(feature = "tokio")]
+//! # #[tokio::main]
+//! # async fn main() -> std::io::Result<()> {
 //! #
 //! use libp2p_core::{transport::ListenerId, Multiaddr, Transport};
 //! use libp2p_quic as quic;
 //!
 //! let keypair = libp2p_identity::Keypair::generate_ed25519();
 //! let quic_config = quic::Config::new(&keypair);
-//!
-//! let mut quic_transport = quic::async_std::Transport::new(quic_config);
-//!
+//! let mut quic_transport = quic::tokio::Transport::new(quic_config);
 //! let addr = "/ip4/127.0.0.1/udp/12345/quic-v1"
 //!     .parse()
 //!     .expect("address should be valid");
 //! quic_transport
 //!     .listen_on(ListenerId::next(), addr)
 //!     .expect("listen error.");
+//!
 //! #
 //! # Ok(())
 //! # }
@@ -70,8 +70,6 @@ use std::net::SocketAddr;
 
 pub use config::Config;
 pub use connection::{Connecting, Connection, Stream};
-#[cfg(feature = "async-std")]
-pub use provider::async_std;
 #[cfg(feature = "tokio")]
 pub use provider::tokio;
 pub use provider::Provider;