Merge branch 'master' into connection-limit-whitelist

Cargo.toml

@@ -100,7 +100,7 @@ libp2p-request-response = { version = "0.28.1", path = "protocols/request-respon
 libp2p-server = { version = "0.12.6", path = "misc/server" }
 libp2p-stream = { version = "0.3.0-alpha", path = "protocols/stream" }
 libp2p-swarm = { version = "0.46.0", path = "swarm" }
-libp2p-swarm-derive = { version = "=0.35.0", 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-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" }
 libp2p-tls = { version = "0.6.0", path = "transports/tls" }

swarm-derive/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.35.1
+
+- Fix `NetworkBehaviour` derive macro: replace the `Result` with `std::result::Result`.
+  See [PR 4568](https://github.com/libp2p/rust-libp2p/pull/5839)
+
 ## 0.35.0
 
 - Implement refactored `Transport`.

swarm-derive/Cargo.toml

@@ -3,7 +3,7 @@ name = "libp2p-swarm-derive"
 edition = "2021"
 rust-version = { workspace = true }
 description = "Procedural macros of libp2p-swarm"
-version = "0.35.0"
+version = "0.35.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

swarm-derive/src/lib.rs

@@ -170,7 +170,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                         }
 
                         impl #impl_generics ::core::fmt::Debug for #enum_name #ty_generics #where_clause_debug {
-                            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+                            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
                                 match &self {
                                     #(#enum_name::#match_variants(event) => {
                                         write!(f, "{}: {:?}", #enum_name_str, event)
@@ -426,7 +426,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                 connection_id: #connection_id,
                 local_addr: &#multiaddr,
                 remote_addr: &#multiaddr,
-            ) -> Result<(), #connection_denied> {
+            ) -> std::result::Result<(), #connection_denied> {
                 #(#handle_pending_inbound_connection_stmts)*
 
                 Ok(())
@@ -439,7 +439,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                 peer: #peer_id,
                 local_addr: &#multiaddr,
                 remote_addr: &#multiaddr,
-            ) -> Result<#t_handler<Self>, #connection_denied> {
+            ) -> std::result::Result<#t_handler<Self>, #connection_denied> {
                 Ok(#handle_established_inbound_connection)
             }
 
@@ -450,7 +450,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                 maybe_peer: Option<#peer_id>,
                 addresses: &[#multiaddr],
                 effective_role: #endpoint,
-            ) -> Result<::std::vec::Vec<#multiaddr>, #connection_denied> {
+            ) -> std::result::Result<::std::vec::Vec<#multiaddr>, #connection_denied> {
                 #handle_pending_outbound_connection
             }
 
@@ -462,7 +462,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                 addr: &#multiaddr,
                 role_override: #endpoint,
                 port_use: #port_use,
-            ) -> Result<#t_handler<Self>, #connection_denied> {
+            ) -> std::result::Result<#t_handler<Self>, #connection_denied> {
                 Ok(#handle_established_outbound_connection)
             }
 

transports/quic/Cargo.toml

@@ -35,19 +35,18 @@ async-std = ["dep:async-std", "if-watch/smol", "quinn/runtime-async-std"]
 all-features = true
 
 [dev-dependencies]
-async-std = { version = "1.12.0", features = ["attributes"] }
 libp2p-identity = { workspace = true, features = ["rand"] }
 libp2p-muxer-test-harness = { path = "../../muxers/test-harness" }
 libp2p-noise = { workspace = true }
-libp2p-tcp = { workspace = true, features = ["async-io"] }
+libp2p-tcp = { workspace = true, features = ["tokio"] }
 libp2p-yamux = { workspace = true }
 quickcheck = "1"
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 [[test]]
 name = "stream_compliance"
-required-features = ["async-std"]
+required-features = ["tokio"]
 
 [lints]
 workspace = true

transports/quic/src/transport.rs

@@ -845,12 +845,12 @@ mod tests {
         );
     }
 
-    #[cfg(feature = "async-std")]
-    #[async_std::test]
+    #[cfg(feature = "tokio")]
+    #[tokio::test]
     async fn test_close_listener() {
         let keypair = libp2p_identity::Keypair::generate_ed25519();
         let config = Config::new(&keypair);
-        let mut transport = crate::async_std::Transport::new(config);
+        let mut transport = crate::tokio::Transport::new(config);
         assert!(poll_fn(|cx| Pin::new(&mut transport).as_mut().poll(cx))
             .now_or_never()
             .is_none());

transports/quic/tests/smoke.rs

@@ -41,10 +41,10 @@ async fn tokio_smoke() {
     smoke::<quic::tokio::Provider>().await
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn async_std_smoke() {
-    smoke::<quic::async_std::Provider>().await
+    smoke::<quic::tokio::Provider>().await
 }
 
 #[cfg(feature = "tokio")]
@@ -74,14 +74,14 @@ async fn endpoint_reuse() {
     assert_eq!(a_send_back_addr, a_addr);
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn ipv4_dial_ipv6() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
-    let (b_peer_id, mut b_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
+    let (b_peer_id, mut b_transport) = create_default_transport::<quic::tokio::Provider>();
 
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
     let ((a_connected, _, _), (b_connected, _)) =
@@ -94,8 +94,8 @@ async fn ipv4_dial_ipv6() {
 /// Tests that a [`Transport::dial`] wakes up the task previously polling [`Transport::poll`].
 ///
 /// See https://github.com/libp2p/rust-libp2p/pull/3306 for context.
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn wrapped_with_delay() {
     use libp2p_core::transport::DialOpts;
 
@@ -161,15 +161,15 @@ async fn wrapped_with_delay() {
         }
     }
 
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
     let (b_peer_id, mut b_transport) = {
-        let (id, transport) = create_default_transport::<quic::async_std::Provider>();
+        let (id, transport) = create_default_transport::<quic::tokio::Provider>();
         (id, DialDelay(Arc::new(Mutex::new(transport))).boxed())
     };
 
     // Spawn A
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
-    let listener = async_std::task::spawn(async move {
+    let listener = tokio::spawn(async move {
         let (upgrade, _) = a_transport
             .select_next_some()
             .await
@@ -184,7 +184,7 @@ async fn wrapped_with_delay() {
     //
     // Note that the dial is spawned on a different task than the transport allowing the transport
     // task to poll the transport once and then suspend, waiting for the wakeup from the dial.
-    let dial = async_std::task::spawn({
+    let dial = tokio::spawn({
         let dial = b_transport
             .dial(
                 a_addr,
@@ -196,23 +196,23 @@ async fn wrapped_with_delay() {
             .unwrap();
         async { dial.await.unwrap().0 }
     });
-    async_std::task::spawn(async move { b_transport.next().await });
+    tokio::spawn(async move { b_transport.next().await });
 
     let (a_connected, b_connected) = future::join(listener, dial).await;
 
-    assert_eq!(a_connected, b_peer_id);
-    assert_eq!(b_connected, a_peer_id);
+    assert_eq!(a_connected.unwrap(), b_peer_id);
+    assert_eq!(b_connected.unwrap(), a_peer_id);
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 #[ignore] // Transport currently does not validate PeerId.
           // Enable once we make use of PeerId validation in rustls.
 async fn wrong_peerid() {
     use libp2p_identity::PeerId;
 
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
-    let (b_peer_id, mut b_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
+    let (b_peer_id, mut b_transport) = create_default_transport::<quic::tokio::Provider>();
 
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
     let a_addr_random_peer = a_addr.with(Protocol::P2p(PeerId::random()));
@@ -224,15 +224,15 @@ async fn wrong_peerid() {
     assert_eq!(b_connected, a_peer_id);
 }
 
-#[cfg(feature = "async-std")]
+#[cfg(feature = "tokio")]
 fn new_tcp_quic_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox)>) {
     let keypair = generate_tls_keypair();
     let peer_id = keypair.public().to_peer_id();
     let mut config = quic::Config::new(&keypair);
     config.handshake_timeout = Duration::from_secs(1);
 
-    let quic_transport = quic::async_std::Transport::new(config);
-    let tcp_transport = tcp::async_io::Transport::new(tcp::Config::default())
+    let quic_transport = quic::tokio::Transport::new(config);
+    let tcp_transport = tcp::tokio::Transport::new(tcp::Config::default())
         .upgrade(upgrade::Version::V1)
         .authenticate(noise::Config::new(&keypair).unwrap())
         .multiplex(yamux::Config::default());
@@ -247,8 +247,8 @@ fn new_tcp_quic_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox)>) {
     (peer_id, transport)
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn tcp_and_quic() {
     let (a_peer_id, mut a_transport) = new_tcp_quic_transport();
     let (b_peer_id, mut b_transport) = new_tcp_quic_transport();
@@ -377,15 +377,15 @@ async fn draft_29_support() {
     }
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn backpressure() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
     let max_stream_data = quic::Config::new(&generate_tls_keypair()).max_stream_data;
 
-    let (mut stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (mut stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
 
     let data = vec![0; max_stream_data as usize - 1];
 
@@ -403,13 +403,13 @@ async fn backpressure() {
     assert!(stream_a.write(&more_data).now_or_never().is_some());
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn read_after_peer_dropped_stream() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (mut stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (mut stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
 
     let data = vec![0; 10];
 
@@ -424,14 +424,14 @@ async fn read_after_peer_dropped_stream() {
     assert_eq!(data, buf)
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 #[should_panic]
 async fn write_after_peer_dropped_stream() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
     drop(stream_a);
     futures_timer::Delay::new(Duration::from_millis(100)).await;
 

transports/quic/tests/stream_compliance.rs

@@ -7,14 +7,14 @@ use libp2p_core::{
 };
 use libp2p_quic as quic;
 
-#[async_std::test]
+#[tokio::test]
 async fn close_implies_flush() {
     let (alice, bob) = connected_peers().await;
 
     libp2p_muxer_test_harness::close_implies_flush(alice, bob).await;
 }
 
-#[async_std::test]
+#[tokio::test]
 async fn read_after_close() {
     let (alice, bob) = connected_peers().await;
 
@@ -36,10 +36,10 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
     let (dialer_conn_sender, dialer_conn_receiver) = oneshot::channel();
     let (listener_conn_sender, listener_conn_receiver) = oneshot::channel();
 
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         let (upgrade, _) = listener.next().await.unwrap().into_incoming().unwrap();
 
-        async_std::task::spawn(async move {
+        tokio::spawn(async move {
             let (_, connection) = upgrade.await.unwrap();
 
             let _ = listener_conn_sender.send(connection);
@@ -58,13 +58,13 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
             },
         )
         .unwrap();
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         let connection = dial_fut.await.unwrap().1;
 
         let _ = dialer_conn_sender.send(connection);
     });
 
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         loop {
             dialer.next().await;
         }
@@ -75,10 +75,10 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
         .unwrap()
 }
 
-fn new_transport() -> quic::async_std::Transport {
+fn new_transport() -> quic::tokio::Transport {
     let keypair = libp2p_identity::Keypair::generate_ed25519();
     let mut config = quic::Config::new(&keypair);
     config.handshake_timeout = Duration::from_secs(1);
 
-    quic::async_std::Transport::new(config)
+    quic::tokio::Transport::new(config)
 }