From 9f4db0a5769ff64fd2a03ddd97479e78fb96cb8b Mon Sep 17 00:00:00 2001 From: umgefahren <55623006+umgefahren@users.noreply.github.com> Date: Mon, 20 Nov 2023 16:32:30 +0100 Subject: [PATCH 1/2] Run cargo fmt (with rustfmt 1.7.0) --- core/src/peer_record.rs | 55 ++- core/src/signed_envelope.rs | 17 +- core/src/transport/memory.rs | 42 +- core/src/transport/upgrade.rs | 50 +- examples/autonat/src/bin/autonat_client.rs | 7 +- examples/autonat/src/bin/autonat_server.rs | 7 +- examples/browser-webrtc/src/lib.rs | 17 +- examples/browser-webrtc/src/main.rs | 33 +- examples/dcutr/src/main.rs | 10 +- examples/file-sharing/src/network.rs | 18 +- examples/identify/src/main.rs | 29 +- examples/ipfs-kad/src/main.rs | 4 +- examples/metrics/src/main.rs | 13 +- examples/rendezvous/src/bin/rzv-identify.rs | 4 +- hole-punching-tests/src/main.rs | 51 +- identity/src/keypair.rs | 30 +- identity/src/lib.rs | 10 +- identity/src/rsa.rs | 6 +- interop-tests/src/arch.rs | 31 +- interop-tests/src/bin/native_ping.rs | 21 +- interop-tests/src/bin/wasm_ping.rs | 9 +- interop-tests/src/lib.rs | 99 ++-- libp2p/src/builder.rs | 13 +- libp2p/src/builder/phase/quic.rs | 6 +- libp2p/src/builder/phase/websocket.rs | 6 +- misc/connection-limits/src/lib.rs | 61 +-- misc/futures-bounded/src/stream_map.rs | 10 +- misc/keygen/src/main.rs | 6 +- misc/metrics/src/bandwidth.rs | 39 +- misc/metrics/src/kad.rs | 24 +- .../src/length_delimited.rs | 51 +- misc/multistream-select/src/protocol.rs | 17 +- misc/server/src/behaviour.rs | 11 +- misc/server/src/http_service.rs | 5 +- misc/server/src/main.rs | 27 +- misc/webrtc-utils/src/noise.rs | 12 +- misc/webrtc-utils/src/sdp.rs | 13 +- muxers/mplex/benches/split_send_size.rs | 29 +- muxers/mplex/src/codec.rs | 23 +- muxers/mplex/src/io.rs | 16 +- muxers/mplex/tests/compliance.rs | 18 +- protocols/autonat/src/behaviour.rs | 41 +- protocols/autonat/src/behaviour/as_client.rs | 21 +- protocols/autonat/src/behaviour/as_server.rs | 16 +- protocols/autonat/src/protocol.rs | 66 +-- protocols/autonat/tests/test_server.rs | 5 +- protocols/dcutr/src/handler/relayed.rs | 24 +- protocols/dcutr/tests/lib.rs | 14 +- protocols/floodsub/src/layer.rs | 4 +- protocols/gossipsub/src/backoff.rs | 9 +- protocols/gossipsub/src/behaviour.rs | 129 ++--- protocols/gossipsub/src/behaviour/tests.rs | 461 +++++++++--------- protocols/gossipsub/src/config.rs | 9 +- protocols/gossipsub/src/handler.rs | 7 +- protocols/gossipsub/src/mcache.rs | 28 +- protocols/gossipsub/src/metrics.rs | 53 +- protocols/gossipsub/src/peer_score.rs | 128 ++--- protocols/gossipsub/src/peer_score/tests.rs | 11 +- protocols/gossipsub/src/protocol.rs | 99 ++-- .../gossipsub/src/subscription_filter.rs | 42 +- protocols/gossipsub/src/topic.rs | 11 +- protocols/identify/src/behaviour.rs | 11 +- protocols/identify/src/handler.rs | 37 +- protocols/identify/src/protocol.rs | 26 +- protocols/identify/tests/smoke.rs | 9 +- protocols/kad/src/behaviour.rs | 152 +++--- protocols/kad/src/behaviour/test.rs | 44 +- protocols/kad/src/handler.rs | 30 +- protocols/kad/src/protocol.rs | 36 +- protocols/kad/src/query.rs | 15 +- protocols/kad/src/query/peers/closest.rs | 16 +- .../kad/src/query/peers/closest/disjoint.rs | 6 +- protocols/kad/src/query/peers/fixed.rs | 9 +- protocols/perf/src/bin/perf.rs | 15 +- protocols/perf/src/client/handler.rs | 7 +- protocols/perf/src/protocol.rs | 11 +- protocols/perf/src/server/handler.rs | 7 +- protocols/ping/src/handler.rs | 23 +- protocols/ping/src/protocol.rs | 5 +- protocols/relay/src/behaviour.rs | 28 +- protocols/relay/src/behaviour/handler.rs | 6 +- protocols/relay/src/behaviour/rate_limiter.rs | 14 +- protocols/relay/src/copy_future.rs | 7 +- protocols/relay/src/priv_client.rs | 181 +++---- protocols/relay/src/priv_client/handler.rs | 36 +- protocols/relay/src/protocol/outbound_hop.rs | 43 +- protocols/relay/tests/lib.rs | 60 +-- protocols/rendezvous/src/codec.rs | 23 +- protocols/rendezvous/src/server.rs | 23 +- protocols/rendezvous/tests/rendezvous.rs | 33 +- protocols/request-response/src/handler.rs | 34 +- protocols/request-response/src/lib.rs | 5 +- .../request-response/tests/error_reporting.rs | 47 +- protocols/request-response/tests/ping.rs | 101 ++-- protocols/upnp/src/behaviour.rs | 21 +- protocols/upnp/src/tokio.rs | 19 +- swarm-derive/src/lib.rs | 228 ++++----- swarm-test/src/lib.rs | 23 +- swarm/src/behaviour.rs | 12 +- swarm/src/behaviour/either.rs | 56 ++- swarm/src/behaviour/toggle.rs | 59 +-- swarm/src/connection.rs | 67 ++- swarm/src/connection/pool/task.rs | 60 +-- swarm/src/handler/either.rs | 70 +-- swarm/src/handler/multi.rs | 32 +- swarm/src/handler/one_shot.rs | 27 +- swarm/src/handler/select.rs | 41 +- swarm/src/lib.rs | 31 +- swarm/src/test.rs | 51 +- swarm/tests/listener.rs | 25 +- transports/dns/src/lib.rs | 96 ++-- transports/noise/src/lib.rs | 30 +- transports/noise/src/protocol.rs | 11 +- transports/plaintext/src/handshake.rs | 42 +- transports/plaintext/tests/smoke.rs | 13 +- transports/pnet/tests/smoke.rs | 23 +- transports/quic/src/transport.rs | 32 +- transports/quic/tests/smoke.rs | 62 +-- transports/tcp/src/lib.rs | 22 +- transports/tcp/src/provider/async_io.rs | 16 +- transports/tls/src/certificate.rs | 16 +- transports/tls/src/lib.rs | 6 +- transports/tls/src/verifier.rs | 4 +- transports/tls/tests/smoke.rs | 23 +- transports/uds/src/lib.rs | 20 +- transports/webrtc-websys/src/connection.rs | 29 +- .../src/stream/poll_data_channel.rs | 15 +- transports/webrtc-websys/src/transport.rs | 9 +- transports/webrtc/src/tokio/certificate.rs | 5 +- transports/webrtc/src/tokio/fingerprint.rs | 4 +- transports/webrtc/src/tokio/sdp.rs | 13 +- transports/webrtc/src/tokio/udp_mux.rs | 32 +- transports/webrtc/src/tokio/upgrade.rs | 22 +- transports/webrtc/tests/smoke.rs | 17 +- transports/websocket-websys/src/lib.rs | 24 +- transports/websocket/src/quicksink.rs | 50 +- .../webtransport-websys/src/bindings.rs | 11 +- .../webtransport-websys/src/endpoint.rs | 28 +- transports/webtransport-websys/src/stream.rs | 19 +- 139 files changed, 2399 insertions(+), 2345 deletions(-) diff --git a/core/src/peer_record.rs b/core/src/peer_record.rs index 2fd6a39ef2b..76258547e54 100644 --- a/core/src/peer_record.rs +++ b/core/src/peer_record.rs @@ -171,37 +171,38 @@ mod tests { let addr: Multiaddr = HOME.parse().unwrap(); - let envelope = { - let identity_a = Keypair::generate_ed25519(); - let identity_b = Keypair::generate_ed25519(); - - let payload = { - let record = proto::PeerRecord { - peer_id: identity_a.public().to_peer_id().to_bytes(), - seq: 0, - addresses: vec![proto::AddressInfo { - multiaddr: addr.to_vec(), - }], + let envelope = + { + let identity_a = Keypair::generate_ed25519(); + let identity_b = Keypair::generate_ed25519(); + + let payload = { + let record = proto::PeerRecord { + peer_id: identity_a.public().to_peer_id().to_bytes(), + seq: 0, + addresses: vec![proto::AddressInfo { + multiaddr: addr.to_vec(), + }], + }; + + let mut buf = Vec::with_capacity(record.get_size()); + let mut writer = Writer::new(&mut buf); + record + .write_message(&mut writer) + .expect("Encoding to succeed"); + + buf }; - let mut buf = Vec::with_capacity(record.get_size()); - let mut writer = Writer::new(&mut buf); - record - .write_message(&mut writer) - .expect("Encoding to succeed"); - - buf + SignedEnvelope::new( + &identity_b, + String::from(DOMAIN_SEP), + PAYLOAD_TYPE.as_bytes().to_vec(), + payload, + ) + .unwrap() }; - SignedEnvelope::new( - &identity_b, - String::from(DOMAIN_SEP), - PAYLOAD_TYPE.as_bytes().to_vec(), - payload, - ) - .unwrap() - }; - assert!(matches!( PeerRecord::from_signed_envelope(envelope), Err(FromEnvelopeError::MismatchedSignature) diff --git a/core/src/signed_envelope.rs b/core/src/signed_envelope.rs index 19a0cac4f82..367887ead86 100644 --- a/core/src/signed_envelope.rs +++ b/core/src/signed_envelope.rs @@ -120,14 +120,15 @@ fn signature_payload(domain_separation: String, payload_type: &[u8], payload: &[ let mut payload_length_buffer = usize_buffer(); let payload_length = unsigned_varint::encode::usize(payload.len(), &mut payload_length_buffer); - let mut buffer = Vec::with_capacity( - domain_sep_length.len() - + domain_separation.len() - + payload_type_length.len() - + payload_type.len() - + payload_length.len() - + payload.len(), - ); + let mut buffer = + Vec::with_capacity( + domain_sep_length.len() + + domain_separation.len() + + payload_type_length.len() + + payload_type.len() + + payload_length.len() + + payload.len(), + ); buffer.extend_from_slice(domain_sep_length); buffer.extend_from_slice(domain_separation.as_bytes()); diff --git a/core/src/transport/memory.rs b/core/src/transport/memory.rs index bf88215dd43..3b39b249028 100644 --- a/core/src/transport/memory.rs +++ b/core/src/transport/memory.rs @@ -550,22 +550,23 @@ mod tests { let mut t1 = MemoryTransport::default().boxed(); - let listener = async move { - t1.listen_on(ListenerId::next(), t1_addr.clone()).unwrap(); - let upgrade = loop { - let event = t1.select_next_some().await; - if let Some(upgrade) = event.into_incoming() { - break upgrade; - } - }; + let listener = + async move { + t1.listen_on(ListenerId::next(), t1_addr.clone()).unwrap(); + let upgrade = loop { + let event = t1.select_next_some().await; + if let Some(upgrade) = event.into_incoming() { + break upgrade; + } + }; - let mut socket = upgrade.0.await.unwrap(); + let mut socket = upgrade.0.await.unwrap(); - let mut buf = [0; 3]; - socket.read_exact(&mut buf).await.unwrap(); + let mut buf = [0; 3]; + socket.read_exact(&mut buf).await.unwrap(); - assert_eq!(buf, msg); - }; + assert_eq!(buf, msg); + }; // Setup dialer. @@ -605,13 +606,14 @@ mod tests { } }; - let dialer = async move { - MemoryTransport::default() - .dial(listener_addr_cloned) - .unwrap() - .await - .unwrap(); - }; + let dialer = + async move { + MemoryTransport::default() + .dial(listener_addr_cloned) + .unwrap() + .await + .unwrap(); + }; futures::executor::block_on(futures::future::join(listener, dialer)); } diff --git a/core/src/transport/upgrade.rs b/core/src/transport/upgrade.rs index 8525ab741ff..5a4c1f4392b 100644 --- a/core/src/transport/upgrade.rs +++ b/core/src/transport/upgrade.rs @@ -212,10 +212,7 @@ where U: OutboundConnectionUpgrade, Output = D, Error = E> + Clone, E: Error + 'static, { - Authenticated(Builder::new( - Upgrade::new(self.0.inner, upgrade), - self.0.version, - )) + Authenticated(Builder::new(Upgrade::new(self.0.inner, upgrade), self.0.version)) } /// Upgrades the transport with a (sub)stream multiplexer. @@ -524,29 +521,30 @@ where let this = &mut *self; loop { - this.upgrade = match this.upgrade { - future::Either::Left(ref mut up) => { - let (i, c) = match ready!(TryFuture::try_poll(this.future.as_mut(), cx) - .map_err(TransportUpgradeError::Transport)) - { - Ok(v) => v, - Err(err) => return Poll::Ready(Err(err)), - }; - let u = up - .take() - .expect("DialUpgradeFuture is constructed with Either::Left(Some)."); - future::Either::Right((i, apply_outbound(c, u, upgrade::Version::V1))) + this.upgrade = + match this.upgrade { + future::Either::Left(ref mut up) => { + let (i, c) = match ready!(TryFuture::try_poll(this.future.as_mut(), cx) + .map_err(TransportUpgradeError::Transport)) + { + Ok(v) => v, + Err(err) => return Poll::Ready(Err(err)), + }; + let u = up + .take() + .expect("DialUpgradeFuture is constructed with Either::Left(Some)."); + future::Either::Right((i, apply_outbound(c, u, upgrade::Version::V1))) + } + future::Either::Right((i, ref mut up)) => { + let d = match ready!(Future::poll(Pin::new(up), cx) + .map_err(TransportUpgradeError::Upgrade)) + { + Ok(d) => d, + Err(err) => return Poll::Ready(Err(err)), + }; + return Poll::Ready(Ok((i, d))); + } } - future::Either::Right((i, ref mut up)) => { - let d = match ready!( - Future::poll(Pin::new(up), cx).map_err(TransportUpgradeError::Upgrade) - ) { - Ok(d) => d, - Err(err) => return Poll::Ready(Err(err)), - }; - return Poll::Ready(Ok((i, d))); - } - } } } } diff --git a/examples/autonat/src/bin/autonat_client.rs b/examples/autonat/src/bin/autonat_client.rs index b071e717731..e51f3e26a90 100644 --- a/examples/autonat/src/bin/autonat_client.rs +++ b/examples/autonat/src/bin/autonat_client.rs @@ -91,10 +91,9 @@ struct Behaviour { impl Behaviour { fn new(local_public_key: identity::PublicKey) -> Self { Self { - identify: identify::Behaviour::new(identify::Config::new( - "/ipfs/0.1.0".into(), - local_public_key.clone(), - )), + identify: identify::Behaviour::new( + identify::Config::new("/ipfs/0.1.0".into(), local_public_key.clone()) + ), auto_nat: autonat::Behaviour::new( local_public_key.to_peer_id(), autonat::Config { diff --git a/examples/autonat/src/bin/autonat_server.rs b/examples/autonat/src/bin/autonat_server.rs index d1c0c005861..496476baa34 100644 --- a/examples/autonat/src/bin/autonat_server.rs +++ b/examples/autonat/src/bin/autonat_server.rs @@ -78,10 +78,9 @@ struct Behaviour { impl Behaviour { fn new(local_public_key: identity::PublicKey) -> Self { Self { - identify: identify::Behaviour::new(identify::Config::new( - "/ipfs/0.1.0".into(), - local_public_key.clone(), - )), + identify: identify::Behaviour::new( + identify::Config::new("/ipfs/0.1.0".into(), local_public_key.clone()) + ), auto_nat: autonat::Behaviour::new( local_public_key.to_peer_id(), autonat::Config { diff --git a/examples/browser-webrtc/src/lib.rs b/examples/browser-webrtc/src/lib.rs index 609d72479c4..6778dcf2730 100644 --- a/examples/browser-webrtc/src/lib.rs +++ b/examples/browser-webrtc/src/lib.rs @@ -18,14 +18,15 @@ pub async fn run(libp2p_endpoint: String) -> Result<(), JsError> { let body = Body::from_current_window()?; body.append_p("Let's ping the WebRTC Server!")?; - let mut swarm = libp2p::SwarmBuilder::with_new_identity() - .with_wasm_bindgen() - .with_other_transport(|key| { - webrtc_websys::Transport::new(webrtc_websys::Config::new(&key)) - })? - .with_behaviour(|_| ping::Behaviour::new(ping::Config::new()))? - .with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(5))) - .build(); + let mut swarm = + libp2p::SwarmBuilder::with_new_identity() + .with_wasm_bindgen() + .with_other_transport( + |key| webrtc_websys::Transport::new(webrtc_websys::Config::new(&key)) + )? + .with_behaviour(|_| ping::Behaviour::new(ping::Config::new()))? + .with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(5))) + .build(); let addr = libp2p_endpoint.parse::()?; tracing::info!("Dialing {addr}"); diff --git a/examples/browser-webrtc/src/main.rs b/examples/browser-webrtc/src/main.rs index 098b70f3054..78e2e6f82d6 100644 --- a/examples/browser-webrtc/src/main.rs +++ b/examples/browser-webrtc/src/main.rs @@ -49,23 +49,24 @@ async fn main() -> anyhow::Result<()> { swarm.listen_on(address_webrtc.clone())?; - let address = loop { - if let SwarmEvent::NewListenAddr { address, .. } = swarm.select_next_some().await { - if address - .iter() - .any(|e| e == Protocol::Ip4(Ipv4Addr::LOCALHOST)) - { - tracing::debug!( - "Ignoring localhost address to make sure the example works in Firefox" - ); - continue; + let address = + loop { + if let SwarmEvent::NewListenAddr { address, .. } = swarm.select_next_some().await { + if address + .iter() + .any(|e| e == Protocol::Ip4(Ipv4Addr::LOCALHOST)) + { + tracing::debug!( + "Ignoring localhost address to make sure the example works in Firefox" + ); + continue; + } + + tracing::info!(%address, "Listening"); + + break address; } - - tracing::info!(%address, "Listening"); - - break address; - } - }; + }; let addr = address.with(Protocol::P2p(*swarm.local_peer_id())); diff --git a/examples/dcutr/src/main.rs b/examples/dcutr/src/main.rs index 91beaa02c67..e7baee339b4 100644 --- a/examples/dcutr/src/main.rs +++ b/examples/dcutr/src/main.rs @@ -148,9 +148,7 @@ async fn main() -> Result<(), Box> { SwarmEvent::Dialing { .. } => {} SwarmEvent::ConnectionEstablished { .. } => {} SwarmEvent::Behaviour(BehaviourEvent::Ping(_)) => {} - SwarmEvent::Behaviour(BehaviourEvent::Identify(identify::Event::Sent { - .. - })) => { + SwarmEvent::Behaviour(BehaviourEvent::Identify(identify::Event::Sent { .. })) => { tracing::info!("Told relay its public address"); told_relay_observed_addr = true; } @@ -193,9 +191,9 @@ async fn main() -> Result<(), Box> { SwarmEvent::NewListenAddr { address, .. } => { tracing::info!(%address, "Listening on address"); } - SwarmEvent::Behaviour(BehaviourEvent::RelayClient( - relay::client::Event::ReservationReqAccepted { .. }, - )) => { + SwarmEvent::Behaviour( + BehaviourEvent::RelayClient(relay::client::Event::ReservationReqAccepted { .. }) + ) => { assert!(opts.mode == Mode::Listen); tracing::info!("Relay accepted our reservation request"); } diff --git a/examples/file-sharing/src/network.rs b/examples/file-sharing/src/network.rs index ad5418193a4..9ef01b8ee18 100644 --- a/examples/file-sharing/src/network.rs +++ b/examples/file-sharing/src/network.rs @@ -247,16 +247,16 @@ impl EventLoop { SwarmEvent::Behaviour(BehaviourEvent::Kademlia( kad::Event::OutboundQueryProgressed { result: - kad::QueryResult::GetProviders(Ok( - kad::GetProvidersOk::FinishedWithNoAdditionalRecord { .. }, - )), + kad::QueryResult::GetProviders( + Ok(kad::GetProvidersOk::FinishedWithNoAdditionalRecord { .. }) + ), .. }, )) => {} SwarmEvent::Behaviour(BehaviourEvent::Kademlia(_)) => {} - SwarmEvent::Behaviour(BehaviourEvent::RequestResponse( - request_response::Event::Message { message, .. }, - )) => match message { + SwarmEvent::Behaviour( + BehaviourEvent::RequestResponse(request_response::Event::Message { message, .. }) + ) => match message { request_response::Message::Request { request, channel, .. } => { @@ -290,9 +290,9 @@ impl EventLoop { .expect("Request to still be pending.") .send(Err(Box::new(error))); } - SwarmEvent::Behaviour(BehaviourEvent::RequestResponse( - request_response::Event::ResponseSent { .. }, - )) => {} + SwarmEvent::Behaviour( + BehaviourEvent::RequestResponse(request_response::Event::ResponseSent { .. }) + ) => {} SwarmEvent::NewListenAddr { address, .. } => { let local_peer_id = *self.swarm.local_peer_id(); eprintln!( diff --git a/examples/identify/src/main.rs b/examples/identify/src/main.rs index 3c40addbcf8..bc94b87e545 100644 --- a/examples/identify/src/main.rs +++ b/examples/identify/src/main.rs @@ -31,20 +31,21 @@ async fn main() -> Result<(), Box> { .with_env_filter(EnvFilter::from_default_env()) .try_init(); - let mut swarm = libp2p::SwarmBuilder::with_new_identity() - .with_async_std() - .with_tcp( - tcp::Config::default(), - noise::Config::new, - yamux::Config::default, - )? - .with_behaviour(|key| { - identify::Behaviour::new(identify::Config::new( - "/ipfs/id/1.0.0".to_string(), - key.public(), - )) - })? - .build(); + let mut swarm = + libp2p::SwarmBuilder::with_new_identity() + .with_async_std() + .with_tcp( + tcp::Config::default(), + noise::Config::new, + yamux::Config::default, + )? + .with_behaviour(|key| { + identify::Behaviour::new(identify::Config::new( + "/ipfs/id/1.0.0".to_string(), + key.public(), + )) + })? + .build(); // Tell the swarm to listen on all interfaces and a random, OS-assigned // port. diff --git a/examples/ipfs-kad/src/main.rs b/examples/ipfs-kad/src/main.rs index 0d11bdd851a..65f74f2e08d 100644 --- a/examples/ipfs-kad/src/main.rs +++ b/examples/ipfs-kad/src/main.rs @@ -119,9 +119,7 @@ async fn main() -> Result<()> { } SwarmEvent::Behaviour(kad::Event::OutboundQueryProgressed { result: - kad::QueryResult::GetClosestPeers(Err(kad::GetClosestPeersError::Timeout { - .. - })), + kad::QueryResult::GetClosestPeers(Err(kad::GetClosestPeersError::Timeout { .. })), .. }) => { bail!("Query for closest peers timed out") diff --git a/examples/metrics/src/main.rs b/examples/metrics/src/main.rs index 3ab6815cb32..fd17cea7771 100644 --- a/examples/metrics/src/main.rs +++ b/examples/metrics/src/main.rs @@ -88,10 +88,8 @@ fn setup_tracing() -> Result<(), Box> { .tracing() .with_exporter(opentelemetry_otlp::new_exporter().tonic()) .with_trace_config( - sdk::trace::Config::default().with_resource(sdk::Resource::new(vec![KeyValue::new( - "service.name", - "libp2p", - )])), + sdk::trace::Config::default() + .with_resource(sdk::Resource::new(vec![KeyValue::new("service.name", "libp2p")])), ) .install_batch(opentelemetry::runtime::Tokio)?; @@ -118,10 +116,9 @@ impl Behaviour { fn new(local_pub_key: identity::PublicKey) -> Self { Self { ping: ping::Behaviour::default(), - identify: identify::Behaviour::new(identify::Config::new( - "/ipfs/0.1.0".into(), - local_pub_key, - )), + identify: identify::Behaviour::new( + identify::Config::new("/ipfs/0.1.0".into(), local_pub_key) + ), } } } diff --git a/examples/rendezvous/src/bin/rzv-identify.rs b/examples/rendezvous/src/bin/rzv-identify.rs index 1d545592829..abe8f6fe5d2 100644 --- a/examples/rendezvous/src/bin/rzv-identify.rs +++ b/examples/rendezvous/src/bin/rzv-identify.rs @@ -75,9 +75,7 @@ async fn main() { tracing::error!("Lost connection to rendezvous point {}", error); } // once `/identify` did its job, we know our external address and can register - SwarmEvent::Behaviour(MyBehaviourEvent::Identify(identify::Event::Received { - .. - })) => { + SwarmEvent::Behaviour(MyBehaviourEvent::Identify(identify::Event::Received { .. })) => { if let Err(error) = swarm.behaviour_mut().rendezvous.register( rendezvous::Namespace::from_static("rendezvous"), rendezvous_point, diff --git a/hole-punching-tests/src/main.rs b/hole-punching-tests/src/main.rs index 4f81cd65480..c127ab6550d 100644 --- a/hole-punching-tests/src/main.rs +++ b/hole-punching-tests/src/main.rs @@ -98,9 +98,9 @@ async fn main() -> Result<()> { id, ) { ( - SwarmEvent::Behaviour(BehaviourEvent::RelayClient( - relay::client::Event::ReservationReqAccepted { .. }, - )), + SwarmEvent::Behaviour( + BehaviourEvent::RelayClient(relay::client::Event::ReservationReqAccepted { .. }) + ), _, _, ) => { @@ -237,27 +237,28 @@ async fn client_setup( relay_addr: Multiaddr, mode: Mode, ) -> Result> { - let either = match mode { - Mode::Listen => { - let id = swarm.listen_on(relay_addr.with(Protocol::P2pCircuit))?; + let either = + match mode { + Mode::Listen => { + let id = swarm.listen_on(relay_addr.with(Protocol::P2pCircuit))?; - Either::Left(id) - } - Mode::Dial => { - let remote_peer_id = redis.pop(LISTEN_CLIENT_PEER_ID).await?; + Either::Left(id) + } + Mode::Dial => { + let remote_peer_id = redis.pop(LISTEN_CLIENT_PEER_ID).await?; - let opts = DialOpts::from( - relay_addr - .with(Protocol::P2pCircuit) - .with(Protocol::P2p(remote_peer_id)), - ); - let id = opts.connection_id(); + let opts = DialOpts::from( + relay_addr + .with(Protocol::P2pCircuit) + .with(Protocol::P2p(remote_peer_id)), + ); + let id = opts.connection_id(); - swarm.dial(opts)?; + swarm.dial(opts)?; - Either::Right(id) - } - }; + Either::Right(id) + } + }; Ok(either) } @@ -332,10 +333,7 @@ impl FromStr for TransportProtocol { match mode { "tcp" => Ok(TransportProtocol::Tcp), "quic" => Ok(TransportProtocol::Quic), - _ => Err(io::Error::new( - io::ErrorKind::Other, - "Expected either 'tcp' or 'quic'", - )), + _ => Err(io::Error::new(io::ErrorKind::Other, "Expected either 'tcp' or 'quic'")), } } } @@ -352,10 +350,7 @@ impl FromStr for Mode { match mode { "dial" => Ok(Mode::Dial), "listen" => Ok(Mode::Listen), - _ => Err(io::Error::new( - io::ErrorKind::Other, - "Expected either 'dial' or 'listen'", - )), + _ => Err(io::Error::new(io::ErrorKind::Other, "Expected either 'dial' or 'listen'")), } } } diff --git a/identity/src/keypair.rs b/identity/src/keypair.rs index bdfb68c0091..604a6e9b44f 100644 --- a/identity/src/keypair.rs +++ b/identity/src/keypair.rs @@ -170,9 +170,9 @@ impl Keypair { #[cfg(feature = "ed25519")] pub fn ed25519_from_bytes(bytes: impl AsMut<[u8]>) -> Result { Ok(Keypair { - keypair: KeyPairInner::Ed25519(ed25519::Keypair::from( - ed25519::SecretKey::try_from_bytes(bytes)?, - )), + keypair: KeyPairInner::Ed25519( + ed25519::Keypair::from(ed25519::SecretKey::try_from_bytes(bytes)?) + ), }) } @@ -665,11 +665,13 @@ impl TryFrom for PublicKey { fn try_from(pubkey: proto::PublicKey) -> Result { match pubkey.Type { #[cfg(feature = "ed25519")] - proto::KeyType::Ed25519 => Ok(ed25519::PublicKey::try_from_bytes(&pubkey.Data).map( - |kp| PublicKey { - publickey: PublicKeyInner::Ed25519(kp), - }, - )?), + proto::KeyType::Ed25519 => { + Ok( + ed25519::PublicKey::try_from_bytes(&pubkey.Data).map(|kp| PublicKey { + publickey: PublicKeyInner::Ed25519(kp), + })?, + ) + } #[cfg(not(feature = "ed25519"))] proto::KeyType::Ed25519 => { tracing::debug!("support for ed25519 was disabled at compile-time"); @@ -699,11 +701,13 @@ impl TryFrom for PublicKey { Err(DecodingError::missing_feature("secp256k1")) } #[cfg(feature = "ecdsa")] - proto::KeyType::ECDSA => Ok(ecdsa::PublicKey::try_decode_der(&pubkey.Data).map( - |kp| PublicKey { - publickey: PublicKeyInner::Ecdsa(kp), - }, - )?), + proto::KeyType::ECDSA => { + Ok( + ecdsa::PublicKey::try_decode_der(&pubkey.Data).map(|kp| PublicKey { + publickey: PublicKeyInner::Ecdsa(kp), + })?, + ) + } #[cfg(not(feature = "ecdsa"))] proto::KeyType::ECDSA => { tracing::debug!("support for ECDSA was disabled at compile-time"); diff --git a/identity/src/lib.rs b/identity/src/lib.rs index c78e68d1652..22cc686a718 100644 --- a/identity/src/lib.rs +++ b/identity/src/lib.rs @@ -86,10 +86,12 @@ impl From<&PublicKey> for proto::PublicKey { fn from(key: &PublicKey) -> Self { match &key.publickey { #[cfg(feature = "ed25519")] - keypair::PublicKeyInner::Ed25519(key) => proto::PublicKey { - Type: proto::KeyType::Ed25519, - Data: key.to_bytes().to_vec(), - }, + keypair::PublicKeyInner::Ed25519(key) => { + proto::PublicKey { + Type: proto::KeyType::Ed25519, + Data: key.to_bytes().to_vec(), + } + } #[cfg(all(feature = "rsa", not(target_arch = "wasm32")))] keypair::PublicKeyInner::Rsa(key) => proto::PublicKey { Type: proto::KeyType::RSA, diff --git a/identity/src/rsa.rs b/identity/src/rsa.rs index cbfe3c1b919..760df2c09b5 100644 --- a/identity/src/rsa.rs +++ b/identity/src/rsa.rs @@ -269,9 +269,9 @@ impl DerEncodable for Asn1SubjectPublicKey { impl DerDecodable<'_> for Asn1SubjectPublicKey { fn load(object: DerObject<'_>) -> Result { if object.tag() != 3 { - return Err(Asn1DerError::new(Asn1DerErrorVariant::InvalidData( - "DER object tag is not the bit string tag.", - ))); + return Err(Asn1DerError::new( + Asn1DerErrorVariant::InvalidData("DER object tag is not the bit string tag.") + )); } let pk_der: Vec = object.value().iter().skip(1).cloned().collect(); diff --git a/interop-tests/src/arch.rs b/interop-tests/src/arch.rs index 52000f90a86..ad795bdf4de 100644 --- a/interop-tests/src/arch.rs +++ b/interop-tests/src/arch.rs @@ -167,9 +167,7 @@ pub(crate) mod native { impl RedisClient { pub(crate) fn new(redis_addr: &str) -> Result { - Ok(Self( - redis::Client::open(redis_addr).context("Could not connect to redis")?, - )) + Ok(Self(redis::Client::open(redis_addr).context("Could not connect to redis")?)) } pub(crate) async fn blpop(&self, key: &str, timeout: u64) -> Result> { @@ -222,9 +220,9 @@ pub(crate) mod wasm { libp2p::SwarmBuilder::with_new_identity() .with_wasm_bindgen() .with_other_transport(|local_key| { - webtransport_websys::Transport::new(webtransport_websys::Config::new( - &local_key, - )) + webtransport_websys::Transport::new( + webtransport_websys::Config::new(&local_key) + ) })? .with_behaviour(behaviour_constructor)? .with_swarm_config(|c| c.with_idle_connection_timeout(Duration::from_secs(5))) @@ -288,16 +286,17 @@ pub(crate) mod wasm { } pub(crate) async fn blpop(&self, key: &str, timeout: u64) -> Result> { - let res = reqwest::Client::new() - .post(&format!("http://{}/blpop", self.0)) - .json(&BlpopRequest { - key: key.to_owned(), - timeout, - }) - .send() - .await? - .json() - .await?; + let res = + reqwest::Client::new() + .post(&format!("http://{}/blpop", self.0)) + .json(&BlpopRequest { + key: key.to_owned(), + timeout, + }) + .send() + .await? + .json() + .await?; Ok(res) } diff --git a/interop-tests/src/bin/native_ping.rs b/interop-tests/src/bin/native_ping.rs index 2fb6ce12e29..929102dfbb9 100644 --- a/interop-tests/src/bin/native_ping.rs +++ b/interop-tests/src/bin/native_ping.rs @@ -6,16 +6,17 @@ mod config; async fn main() -> Result<()> { let config = config::Config::from_env()?; - let report = interop_tests::run_test( - &config.transport, - &config.ip, - config.is_dialer, - config.test_timeout, - &config.redis_addr, - config.sec_protocol, - config.muxer, - ) - .await?; + let report = + interop_tests::run_test( + &config.transport, + &config.ip, + config.is_dialer, + config.test_timeout, + &config.redis_addr, + config.sec_protocol, + config.muxer, + ) + .await?; println!("{}", serde_json::to_string(&report)?); diff --git a/interop-tests/src/bin/wasm_ping.rs b/interop-tests/src/bin/wasm_ping.rs index 8269ff064ad..0305bec6ea1 100644 --- a/interop-tests/src/bin/wasm_ping.rs +++ b/interop-tests/src/bin/wasm_ping.rs @@ -108,10 +108,11 @@ async fn open_in_browser() -> Result<(Child, WebDriver)> { } else { "chromedriver" }; - let mut chrome = tokio::process::Command::new(chromedriver) - .arg("--port=45782") - .stdout(Stdio::piped()) - .spawn()?; + let mut chrome = + tokio::process::Command::new(chromedriver) + .arg("--port=45782") + .stdout(Stdio::piped()) + .spawn()?; // read driver's stdout let driver_out = chrome .stdout diff --git a/interop-tests/src/lib.rs b/interop-tests/src/lib.rs index 0154bec51a4..76323cb1f81 100644 --- a/interop-tests/src/lib.rs +++ b/interop-tests/src/lib.rs @@ -26,20 +26,22 @@ pub async fn run_test( let test_timeout = Duration::from_secs(test_timeout_seconds); let transport = transport.parse().context("Couldn't parse transport")?; - let sec_protocol = sec_protocol - .map(|sec_protocol| { - sec_protocol - .parse() - .context("Couldn't parse security protocol") - }) - .transpose()?; - let muxer = muxer - .map(|sec_protocol| { - sec_protocol - .parse() - .context("Couldn't parse muxer protocol") - }) - .transpose()?; + let sec_protocol = + sec_protocol + .map(|sec_protocol| { + sec_protocol + .parse() + .context("Couldn't parse security protocol") + }) + .transpose()?; + let muxer = + muxer + .map(|sec_protocol| { + sec_protocol + .parse() + .context("Couldn't parse muxer protocol") + }) + .transpose()?; let redis_client = RedisClient::new(redis_addr).context("Could not connect to redis")?; @@ -51,11 +53,12 @@ pub async fn run_test( // See https://github.com/libp2p/rust-libp2p/issues/4071. #[cfg(not(target_arch = "wasm32"))] - let maybe_id = if transport == Transport::WebRtcDirect { - Some(swarm.listen_on(local_addr.parse()?)?) - } else { - None - }; + let maybe_id = + if transport == Transport::WebRtcDirect { + Some(swarm.listen_on(local_addr.parse()?)?) + } else { + None + }; #[cfg(target_arch = "wasm32")] let maybe_id = None; @@ -76,16 +79,17 @@ pub async fn run_test( swarm.dial(other.parse::()?)?; tracing::info!(listener=%other, "Test instance, dialing multiaddress"); - let rtt = loop { - if let Some(SwarmEvent::Behaviour(BehaviourEvent::Ping(ping::Event { - result: Ok(rtt), - .. - }))) = swarm.next().await - { - tracing::info!(?rtt, "Ping successful"); - break rtt.as_micros() as f32 / 1000.; - } - }; + let rtt = + loop { + if let Some(SwarmEvent::Behaviour(BehaviourEvent::Ping(ping::Event { + result: Ok(rtt), + .. + }))) = swarm.next().await + { + tracing::info!(?rtt, "Ping successful"); + break rtt.as_micros() as f32 / 1000.; + } + }; let handshake_plus_ping = handshake_start.elapsed().as_micros() as f32 / 1000.; Ok(Report { @@ -96,10 +100,11 @@ pub async fn run_test( false => { // Listen if we haven't done so already. // This is a hack until https://github.com/libp2p/rust-libp2p/issues/4071 is fixed at which point we can do this unconditionally here. - let id = match maybe_id { - None => swarm.listen_on(local_addr.parse()?)?, - Some(id) => id, - }; + let id = + match maybe_id { + None => swarm.listen_on(local_addr.parse()?)?, + Some(id) => id, + }; tracing::info!( address=%local_addr, @@ -154,16 +159,17 @@ pub async fn run_test_wasm( sec_protocol: Option, muxer: Option, ) -> Result<(), JsValue> { - let result = run_test( - transport, - ip, - is_dialer, - test_timeout_secs, - base_url, - sec_protocol, - muxer, - ) - .await; + let result = + run_test( + transport, + ip, + is_dialer, + test_timeout_secs, + base_url, + sec_protocol, + muxer, + ) + .await; tracing::info!(?result, "Sending test result"); reqwest::Client::new() .post(&format!("http://{}/results", base_url)) @@ -266,9 +272,8 @@ pub(crate) fn build_behaviour(key: &Keypair) -> Behaviour { Behaviour { ping: ping::Behaviour::new(ping::Config::new().with_interval(Duration::from_secs(1))), // Need to include identify until https://github.com/status-im/nim-libp2p/issues/924 is resolved. - identify: identify::Behaviour::new(identify::Config::new( - "/interop-tests".to_owned(), - key.public(), - )), + identify: identify::Behaviour::new( + identify::Config::new("/interop-tests".to_owned(), key.public()) + ), } } diff --git a/libp2p/src/builder.rs b/libp2p/src/builder.rs index c96c20d470a..23ac7757223 100644 --- a/libp2p/src/builder.rs +++ b/libp2p/src/builder.rs @@ -122,12 +122,13 @@ mod tests { #[test] #[cfg(all(feature = "tokio", feature = "quic"))] fn quic() { - let _ = SwarmBuilder::with_new_identity() - .with_tokio() - .with_quic() - .with_behaviour(|_| libp2p_swarm::dummy::Behaviour) - .unwrap() - .build(); + let _ = + SwarmBuilder::with_new_identity() + .with_tokio() + .with_quic() + .with_behaviour(|_| libp2p_swarm::dummy::Behaviour) + .unwrap() + .build(); } #[test] diff --git a/libp2p/src/builder/phase/quic.rs b/libp2p/src/builder/phase/quic.rs index 885b16e2e03..4291d02faa8 100644 --- a/libp2p/src/builder/phase/quic.rs +++ b/libp2p/src/builder/phase/quic.rs @@ -40,9 +40,9 @@ macro_rules! impl_quic_builder { .phase .transport .or_transport( - libp2p_quic::$quic::Transport::new(constructor( - libp2p_quic::Config::new(&self.keypair), - )) + libp2p_quic::$quic::Transport::new( + constructor(libp2p_quic::Config::new(&self.keypair)) + ) .map(|(peer_id, muxer), _| { (peer_id, libp2p_core::muxing::StreamMuxerBox::new(muxer)) }), diff --git a/libp2p/src/builder/phase/websocket.rs b/libp2p/src/builder/phase/websocket.rs index 68a85bb77b7..6f8b1d0af33 100644 --- a/libp2p/src/builder/phase/websocket.rs +++ b/libp2p/src/builder/phase/websocket.rs @@ -116,9 +116,9 @@ macro_rules! impl_websocket_builder { impl_websocket_builder!( "async-std", super::provider::AsyncStd, - libp2p_dns::async_std::Transport::system(libp2p_tcp::async_io::Transport::new( - libp2p_tcp::Config::default(), - )), + libp2p_dns::async_std::Transport::system( + libp2p_tcp::async_io::Transport::new(libp2p_tcp::Config::default(),) + ), rw_stream_sink::RwStreamSink< libp2p_websocket::BytesConnection, > diff --git a/misc/connection-limits/src/lib.rs b/misc/connection-limits/src/lib.rs index af76e9a57d9..fa29aec9e02 100644 --- a/misc/connection-limits/src/lib.rs +++ b/misc/connection-limits/src/lib.rs @@ -428,16 +428,18 @@ mod tests { #[test] fn max_established_incoming() { fn prop(Limit(limit): Limit) { - let mut swarm1 = Swarm::new_ephemeral(|_| { - Behaviour::new( - ConnectionLimits::default().with_max_established_incoming(Some(limit)), - ) - }); - let mut swarm2 = Swarm::new_ephemeral(|_| { - Behaviour::new( - ConnectionLimits::default().with_max_established_incoming(Some(limit)), - ) - }); + let mut swarm1 = + Swarm::new_ephemeral(|_| { + Behaviour::new( + ConnectionLimits::default().with_max_established_incoming(Some(limit)), + ) + }); + let mut swarm2 = + Swarm::new_ephemeral(|_| { + Behaviour::new( + ConnectionLimits::default().with_max_established_incoming(Some(limit)), + ) + }); async_std::task::block_on(async { let (listen_addr, _) = swarm1.listen().with_memory_addr_external().await; @@ -485,9 +487,9 @@ mod tests { /// ([`SwarmEvent::ConnectionEstablished`]) can the connection be seen as established. #[test] fn support_other_behaviour_denying_connection() { - let mut swarm1 = Swarm::new_ephemeral(|_| { - Behaviour::new_with_connection_denier(ConnectionLimits::default()) - }); + let mut swarm1 = Swarm::new_ephemeral( + |_| Behaviour::new_with_connection_denier(ConnectionLimits::default()) + ); let mut swarm2 = Swarm::new_ephemeral(|_| Behaviour::new(ConnectionLimits::default())); async_std::task::block_on(async { @@ -497,15 +499,16 @@ mod tests { async_std::task::spawn(swarm2.loop_on_next()); // Wait for the ConnectionDenier of swarm1 to deny the established connection. - let cause = swarm1 - .wait(|event| match event { - SwarmEvent::IncomingConnectionError { - error: ListenError::Denied { cause }, - .. - } => Some(cause), - _ => None, - }) - .await; + let cause = + swarm1 + .wait(|event| match event { + SwarmEvent::IncomingConnectionError { + error: ListenError::Denied { cause }, + .. + } => Some(cause), + _ => None, + }) + .await; cause.downcast::().unwrap(); @@ -556,10 +559,9 @@ mod tests { _local_addr: &Multiaddr, _remote_addr: &Multiaddr, ) -> Result, ConnectionDenied> { - Err(ConnectionDenied::new(std::io::Error::new( - std::io::ErrorKind::Other, - "ConnectionDenier", - ))) + Err(ConnectionDenied::new( + std::io::Error::new(std::io::ErrorKind::Other, "ConnectionDenier") + )) } fn handle_established_outbound_connection( @@ -569,10 +571,9 @@ mod tests { _addr: &Multiaddr, _role_override: Endpoint, ) -> Result, ConnectionDenied> { - Err(ConnectionDenied::new(std::io::Error::new( - std::io::ErrorKind::Other, - "ConnectionDenier", - ))) + Err(ConnectionDenied::new( + std::io::Error::new(std::io::ErrorKind::Other, "ConnectionDenier") + )) } fn on_swarm_event(&mut self, _event: FromSwarm) {} diff --git a/misc/futures-bounded/src/stream_map.rs b/misc/futures-bounded/src/stream_map.rs index 8464f432d02..d9c04c9f8d3 100644 --- a/misc/futures-bounded/src/stream_map.rs +++ b/misc/futures-bounded/src/stream_map.rs @@ -228,9 +228,8 @@ mod tests { Delay::new(Duration::from_millis(150)).await; poll_fn(|cx| streams.poll_next_unpin(cx)).await; - let poll = streams.poll_next_unpin(&mut Context::from_waker( - futures_util::task::noop_waker_ref(), - )); + let poll = + streams.poll_next_unpin(&mut Context::from_waker(futures_util::task::noop_waker_ref())); assert!(poll.is_pending()) } @@ -245,9 +244,8 @@ mod tests { assert!(cancelled_stream.is_some()); } - let poll = streams.poll_next_unpin(&mut Context::from_waker( - futures_util::task::noop_waker_ref(), - )); + let poll = + streams.poll_next_unpin(&mut Context::from_waker(futures_util::task::noop_waker_ref())); assert!(poll.is_pending()); assert_eq!( diff --git a/misc/keygen/src/main.rs b/misc/keygen/src/main.rs index 64d98005369..b2e18a719e1 100644 --- a/misc/keygen/src/main.rs +++ b/misc/keygen/src/main.rs @@ -54,9 +54,9 @@ fn main() -> Result<(), Box> { Command::From { config } => { let config = Zeroizing::new(config::Config::from_file(config.as_ref())?); - let keypair = identity::Keypair::from_protobuf_encoding(&Zeroizing::new( - BASE64_STANDARD.decode(config.identity.priv_key.as_bytes())?, - ))?; + let keypair = identity::Keypair::from_protobuf_encoding( + &Zeroizing::new(BASE64_STANDARD.decode(config.identity.priv_key.as_bytes())?) + )?; let peer_id = keypair.public().into(); assert_eq!( diff --git a/misc/metrics/src/bandwidth.rs b/misc/metrics/src/bandwidth.rs index 2792e00612c..e47382d7c1c 100644 --- a/misc/metrics/src/bandwidth.rs +++ b/misc/metrics/src/bandwidth.rs @@ -86,12 +86,9 @@ where fn dial(&mut self, addr: Multiaddr) -> Result> { let metrics = ConnectionMetrics::from_family_and_addr(&self.metrics, &addr); - Ok(self - .transport - .dial(addr.clone())? - .map_ok(Box::new(|(peer_id, stream_muxer)| { - (peer_id, Muxer::new(stream_muxer, metrics)) - }))) + Ok(self.transport.dial(addr.clone())?.map_ok( + Box::new(|(peer_id, stream_muxer)| (peer_id, Muxer::new(stream_muxer, metrics))) + )) } fn dial_as_listener( @@ -99,12 +96,9 @@ where addr: Multiaddr, ) -> Result> { let metrics = ConnectionMetrics::from_family_and_addr(&self.metrics, &addr); - Ok(self - .transport - .dial_as_listener(addr.clone())? - .map_ok(Box::new(|(peer_id, stream_muxer)| { - (peer_id, Muxer::new(stream_muxer, metrics)) - }))) + Ok(self.transport.dial_as_listener(addr.clone())?.map_ok( + Box::new(|(peer_id, stream_muxer)| (peer_id, Muxer::new(stream_muxer, metrics))) + )) } fn address_translation(&self, server: &Multiaddr, observed: &Multiaddr) -> Option { @@ -127,9 +121,9 @@ where ConnectionMetrics::from_family_and_addr(this.metrics, &send_back_addr); Poll::Ready(TransportEvent::Incoming { listener_id, - upgrade: upgrade.map_ok(Box::new(|(peer_id, stream_muxer)| { - (peer_id, Muxer::new(stream_muxer, metrics)) - })), + upgrade: upgrade.map_ok(Box::new( + |(peer_id, stream_muxer)| (peer_id, Muxer::new(stream_muxer, metrics)) + )), local_addr, send_back_addr, }) @@ -162,13 +156,14 @@ impl ConnectionMetrics { m.clone() }; // Additional scope to make sure to drop the lock guard from `get_or_create`. - let inbound = { - let m = family.get_or_create(&Labels { - protocols, - direction: Direction::Inbound, - }); - m.clone() - }; + let inbound = + { + let m = family.get_or_create(&Labels { + protocols, + direction: Direction::Inbound, + }); + m.clone() + }; ConnectionMetrics { outbound, inbound } } } diff --git a/misc/metrics/src/kad.rs b/misc/metrics/src/kad.rs index bd5a6526737..f5a9b9ce9db 100644 --- a/misc/metrics/src/kad.rs +++ b/misc/metrics/src/kad.rs @@ -190,24 +190,24 @@ impl super::Recorder for Metrics { .inc(); } }, - libp2p_kad::QueryResult::GetClosestPeers(result) => match result { - Ok(ok) => self - .query_result_get_closest_peers_ok - .observe(ok.peers.len() as f64), - Err(error) => { - self.query_result_get_closest_peers_error - .get_or_create(&error.into()) - .inc(); + libp2p_kad::QueryResult::GetClosestPeers(result) => { + match result { + Ok(ok) => self + .query_result_get_closest_peers_ok + .observe(ok.peers.len() as f64), + Err(error) => { + self.query_result_get_closest_peers_error + .get_or_create(&error.into()) + .inc(); + } } - }, + } libp2p_kad::QueryResult::GetProviders(result) => match result { Ok(libp2p_kad::GetProvidersOk::FoundProviders { providers, .. }) => { self.query_result_get_providers_ok .observe(providers.len() as f64); } - Ok(libp2p_kad::GetProvidersOk::FinishedWithNoAdditionalRecord { - .. - }) => {} + Ok(libp2p_kad::GetProvidersOk::FinishedWithNoAdditionalRecord { .. }) => {} Err(error) => { self.query_result_get_providers_error .get_or_create(&error.into()) diff --git a/misc/multistream-select/src/length_delimited.rs b/misc/multistream-select/src/length_delimited.rs index 6515d00c717..a8563dba1ce 100644 --- a/misc/multistream-select/src/length_delimited.rs +++ b/misc/multistream-select/src/length_delimited.rs @@ -243,15 +243,16 @@ where fn start_send(self: Pin<&mut Self>, item: Bytes) -> Result<(), Self::Error> { let this = self.project(); - let len = match u16::try_from(item.len()) { - Ok(len) if len <= MAX_FRAME_SIZE => len, - _ => { - return Err(io::Error::new( - io::ErrorKind::InvalidData, - "Maximum frame size exceeded.", - )) - } - }; + let len = + match u16::try_from(item.len()) { + Ok(len) if len <= MAX_FRAME_SIZE => len, + _ => { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "Maximum frame size exceeded.", + )) + } + }; let mut uvi_buf = unsigned_varint::encode::u16_buffer(); let uvi_len = unsigned_varint::encode::u16(len, &mut uvi_buf); @@ -491,22 +492,24 @@ mod tests { async_std::task::block_on(async move { let expected_frames = frames.clone(); - let server = async_std::task::spawn(async move { - let mut connec = - rw_stream_sink::RwStreamSink::new(LengthDelimited::new(server_connection)); - - let mut buf = vec![0u8; 0]; - for expected in expected_frames { - if expected.is_empty() { - continue; - } - if buf.len() < expected.len() { - buf.resize(expected.len(), 0); + let server = + async_std::task::spawn(async move { + let mut connec = rw_stream_sink::RwStreamSink::new( + LengthDelimited::new(server_connection) + ); + + let mut buf = vec![0u8; 0]; + for expected in expected_frames { + if expected.is_empty() { + continue; + } + if buf.len() < expected.len() { + buf.resize(expected.len(), 0); + } + let n = connec.read(&mut buf).await.unwrap(); + assert_eq!(&buf[..n], &expected[..]); } - let n = connec.read(&mut buf).await.unwrap(); - assert_eq!(&buf[..n], &expected[..]); - } - }); + }); let client = async_std::task::spawn(async move { let mut connec = LengthDelimited::new(client_connection); diff --git a/misc/multistream-select/src/protocol.rs b/misc/multistream-select/src/protocol.rs index d5c2bfa773a..7fa598481b0 100644 --- a/misc/multistream-select/src/protocol.rs +++ b/misc/multistream-select/src/protocol.rs @@ -394,14 +394,15 @@ fn poll_stream( where S: Stream>, { - let msg = if let Some(msg) = ready!(stream.poll_next(cx)?) { - match Message::decode(msg) { - Ok(m) => m, - Err(err) => return Poll::Ready(Some(Err(err))), - } - } else { - return Poll::Ready(None); - }; + let msg = + if let Some(msg) = ready!(stream.poll_next(cx)?) { + match Message::decode(msg) { + Ok(m) => m, + Err(err) => return Poll::Ready(Some(Err(err))), + } + } else { + return Poll::Ready(None); + }; tracing::trace!(message=?msg, "Received message"); diff --git a/misc/server/src/behaviour.rs b/misc/server/src/behaviour.rs index ec025e02129..883d3a6a05c 100644 --- a/misc/server/src/behaviour.rs +++ b/misc/server/src/behaviour.rs @@ -37,11 +37,12 @@ impl Behaviour { // TODO: Replace hack with option to disable both. kademlia_config.set_record_ttl(Some(Duration::from_secs(0))); kademlia_config.set_provider_record_ttl(Some(Duration::from_secs(0))); - let mut kademlia = kad::Behaviour::with_config( - pub_key.to_peer_id(), - kad::store::MemoryStore::new(pub_key.to_peer_id()), - kademlia_config, - ); + let mut kademlia = + kad::Behaviour::with_config( + pub_key.to_peer_id(), + kad::store::MemoryStore::new(pub_key.to_peer_id()), + kademlia_config, + ); let bootaddr = Multiaddr::from_str("/dnsaddr/bootstrap.libp2p.io").unwrap(); for peer in &BOOTNODES { kademlia.add_address(&PeerId::from_str(peer).unwrap(), bootaddr.clone()); diff --git a/misc/server/src/http_service.rs b/misc/server/src/http_service.rs index 7905933fbf5..10c30fb9d6f 100644 --- a/misc/server/src/http_service.rs +++ b/misc/server/src/http_service.rs @@ -70,10 +70,7 @@ impl MetricService { fn respond_with_404_not_found(&mut self) -> Response { Response::builder() .status(StatusCode::NOT_FOUND) - .body(format!( - "Not found try localhost:[port]/{}", - self.metrics_path - )) + .body(format!("Not found try localhost:[port]/{}", self.metrics_path)) .unwrap() } } diff --git a/misc/server/src/main.rs b/misc/server/src/main.rs index 2349ebf6485..5d13bd1c03d 100644 --- a/misc/server/src/main.rs +++ b/misc/server/src/main.rs @@ -57,21 +57,22 @@ async fn main() -> Result<(), Box> { let mut metric_registry = Registry::default(); - let local_keypair = { - let keypair = identity::Keypair::from_protobuf_encoding(&Zeroizing::new( - base64::engine::general_purpose::STANDARD - .decode(config.identity.priv_key.as_bytes())?, - ))?; - - let peer_id = keypair.public().into(); - assert_eq!( + let local_keypair = + { + let keypair = identity::Keypair::from_protobuf_encoding(&Zeroizing::new( + base64::engine::general_purpose::STANDARD + .decode(config.identity.priv_key.as_bytes())?, + ))?; + + let peer_id = keypair.public().into(); + assert_eq!( PeerId::from_str(&config.identity.peer_id)?, peer_id, "Expect peer id derived from private key and peer id retrieved from config to match." ); - keypair - }; + keypair + }; let mut swarm = libp2p::SwarmBuilder::with_existing_identity(local_keypair) .with_tokio() @@ -83,9 +84,9 @@ async fn main() -> Result<(), Box> { .with_quic() .with_dns()? .with_bandwidth_metrics(&mut metric_registry) - .with_behaviour(|key| { - behaviour::Behaviour::new(key.public(), opt.enable_kademlia, opt.enable_autonat) - })? + .with_behaviour( + |key| behaviour::Behaviour::new(key.public(), opt.enable_kademlia, opt.enable_autonat) + )? .build(); if config.addresses.swarm.is_empty() { diff --git a/misc/webrtc-utils/src/noise.rs b/misc/webrtc-utils/src/noise.rs index ac2e58c9163..b214c5b064c 100644 --- a/misc/webrtc-utils/src/noise.rs +++ b/misc/webrtc-utils/src/noise.rs @@ -92,12 +92,12 @@ mod tests { #[test] fn noise_prologue_tests() { - let a = Fingerprint::raw(hex!( - "3e79af40d6059617a0d83b83a52ce73b0c1f37a72c6043ad2969e2351bdca870" - )); - let b = Fingerprint::raw(hex!( - "30fc9f469c207419dfdd0aab5f27a86c973c94e40548db9375cca2e915973b99" - )); + let a = Fingerprint::raw( + hex!("3e79af40d6059617a0d83b83a52ce73b0c1f37a72c6043ad2969e2351bdca870") + ); + let b = Fingerprint::raw( + hex!("30fc9f469c207419dfdd0aab5f27a86c973c94e40548db9375cca2e915973b99") + ); let prologue1 = noise_prologue(a, b); let prologue2 = noise_prologue(b, a); diff --git a/misc/webrtc-utils/src/sdp.rs b/misc/webrtc-utils/src/sdp.rs index 0796548f449..13b4ce86d7e 100644 --- a/misc/webrtc-utils/src/sdp.rs +++ b/misc/webrtc-utils/src/sdp.rs @@ -27,12 +27,13 @@ use rand::distributions::Alphanumeric; use rand::{thread_rng, Rng}; pub fn answer(addr: SocketAddr, server_fingerprint: Fingerprint, client_ufrag: &str) -> String { - let answer = render_description( - SERVER_SESSION_DESCRIPTION, - addr, - server_fingerprint, - client_ufrag, - ); + let answer = + render_description( + SERVER_SESSION_DESCRIPTION, + addr, + server_fingerprint, + client_ufrag, + ); tracing::trace!(%answer, "Created SDP answer"); diff --git a/muxers/mplex/benches/split_send_size.rs b/muxers/mplex/benches/split_send_size.rs index 9a9814d2f2a..d60d0cc17b6 100644 --- a/muxers/mplex/benches/split_send_size.rs +++ b/muxers/mplex/benches/split_send_size.rs @@ -40,16 +40,17 @@ use tracing_subscriber::EnvFilter; type BenchTransport = transport::Boxed<(PeerId, muxing::StreamMuxerBox)>; /// The sizes (in bytes) used for the `split_send_size` configuration. -const BENCH_SIZES: [usize; 8] = [ - 256, - 512, - 1024, - 8 * 1024, - 16 * 1024, - 64 * 1024, - 256 * 1024, - 1024 * 1024, -]; +const BENCH_SIZES: [usize; 8] = + [ + 256, + 512, + 1024, + 8 * 1024, + 16 * 1024, + 64 * 1024, + 256 * 1024, + 1024 * 1024, + ]; fn prepare(c: &mut Criterion) { let _ = tracing_subscriber::fmt() @@ -174,9 +175,7 @@ fn tcp_transport(split_send_size: usize) -> BenchTransport { libp2p_tcp::async_io::Transport::new(libp2p_tcp::Config::default().nodelay(true)) .upgrade(upgrade::Version::V1) - .authenticate(plaintext::Config::new( - &identity::Keypair::generate_ed25519(), - )) + .authenticate(plaintext::Config::new(&identity::Keypair::generate_ed25519())) .multiplex(mplex) .timeout(Duration::from_secs(5)) .boxed() @@ -188,9 +187,7 @@ fn mem_transport(split_send_size: usize) -> BenchTransport { transport::MemoryTransport::default() .upgrade(upgrade::Version::V1) - .authenticate(plaintext::Config::new( - &identity::Keypair::generate_ed25519(), - )) + .authenticate(plaintext::Config::new(&identity::Keypair::generate_ed25519())) .multiplex(mplex) .timeout(Duration::from_secs(5)) .boxed() diff --git a/muxers/mplex/src/codec.rs b/muxers/mplex/src/codec.rs index 014ee899280..01e2eba52bc 100644 --- a/muxers/mplex/src/codec.rs +++ b/muxers/mplex/src/codec.rs @@ -205,15 +205,17 @@ impl Decoder for Codec { fn decode(&mut self, src: &mut BytesMut) -> Result, Self::Error> { loop { match mem::replace(&mut self.decoder_state, CodecDecodeState::Poisoned) { - CodecDecodeState::Begin => match self.varint_decoder.decode(src)? { - Some(header) => { - self.decoder_state = CodecDecodeState::HasHeader(header); - } - None => { - self.decoder_state = CodecDecodeState::Begin; - return Ok(None); + CodecDecodeState::Begin => { + match self.varint_decoder.decode(src)? { + Some(header) => { + self.decoder_state = CodecDecodeState::HasHeader(header); + } + None => { + self.decoder_state = CodecDecodeState::Begin; + return Ok(None); + } } - }, + } CodecDecodeState::HasHeader(header) => match self.varint_decoder.decode(src)? { Some(len) => { if len as usize > MAX_FRAME_SIZE { @@ -345,10 +347,7 @@ impl Encoder for Codec { let data_len_bytes = encode::usize(data_len, &mut data_buf); if data_len > MAX_FRAME_SIZE { - return Err(io::Error::new( - io::ErrorKind::InvalidData, - "data size exceed maximum", - )); + return Err(io::Error::new(io::ErrorKind::InvalidData, "data size exceed maximum")); } dst.reserve(header_bytes.len() + data_len_bytes.len() + data_len); diff --git a/muxers/mplex/src/io.rs b/muxers/mplex/src/io.rs index 753294a7845..014a27612a6 100644 --- a/muxers/mplex/src/io.rs +++ b/muxers/mplex/src/io.rs @@ -894,10 +894,7 @@ where /// has not been reached. fn check_max_pending_frames(&mut self) -> io::Result<()> { if self.pending_frames.len() >= self.config.max_substreams + EXTRA_PENDING_FRAMES { - return self.on_error(io::Error::new( - io::ErrorKind::Other, - "Too many pending frames.", - )); + return self.on_error(io::Error::new(io::ErrorKind::Other, "Too many pending frames.")); } Ok(()) } @@ -1257,11 +1254,12 @@ mod tests { } // Setup the multiplexed connection. - let conn = Connection { - r_buf, - w_buf: BytesMut::new(), - eof: false, - }; + let conn = + Connection { + r_buf, + w_buf: BytesMut::new(), + eof: false, + }; let mut m = Multiplexed::new(conn, cfg.clone()); task::block_on(future::poll_fn(move |cx| { diff --git a/muxers/mplex/tests/compliance.rs b/muxers/mplex/tests/compliance.rs index d3bcd37bf34..8045a0c456b 100644 --- a/muxers/mplex/tests/compliance.rs +++ b/muxers/mplex/tests/compliance.rs @@ -2,18 +2,24 @@ use libp2p_mplex::MplexConfig; #[async_std::test] async fn close_implies_flush() { - let (alice, bob) = - libp2p_muxer_test_harness::connected_muxers_on_memory_ring_buffer::() - .await; + let (alice, bob) = libp2p_muxer_test_harness::connected_muxers_on_memory_ring_buffer::< + MplexConfig, + _, + _, + >() + .await; libp2p_muxer_test_harness::close_implies_flush(alice, bob).await; } #[async_std::test] async fn read_after_close() { - let (alice, bob) = - libp2p_muxer_test_harness::connected_muxers_on_memory_ring_buffer::() - .await; + let (alice, bob) = libp2p_muxer_test_harness::connected_muxers_on_memory_ring_buffer::< + MplexConfig, + _, + _, + >() + .await; libp2p_muxer_test_harness::read_after_close(alice, bob).await; } diff --git a/protocols/autonat/src/behaviour.rs b/protocols/autonat/src/behaviour.rs index 0b80a079c0f..ec0b2b8ea4e 100644 --- a/protocols/autonat/src/behaviour.rs +++ b/protocols/autonat/src/behaviour.rs @@ -328,12 +328,13 @@ impl Behaviour { ) { let connections = self.connected.entry(peer).or_default(); let addr = endpoint.get_remote_address(); - let observed_addr = - if !endpoint.is_relayed() && (!self.config.only_global_ips || addr.is_global_ip()) { - Some(addr.clone()) - } else { - None - }; + let observed_addr = if !endpoint.is_relayed() + && (!self.config.only_global_ips || addr.is_global_ip()) + { + Some(addr.clone()) + } else { + None + }; connections.insert(conn, observed_addr); match endpoint { @@ -420,12 +421,13 @@ impl Behaviour { } let connections = self.connected.get_mut(&peer).expect("Peer is connected."); let addr = new.get_remote_address(); - let observed_addr = - if !new.is_relayed() && (!self.config.only_global_ips || addr.is_global_ip()) { - Some(addr.clone()) - } else { - None - }; + let observed_addr = if !new.is_relayed() + && (!self.config.only_global_ips || addr.is_global_ip()) + { + Some(addr.clone()) + } else { + None + }; connections.insert(conn, observed_addr); } } @@ -563,11 +565,9 @@ impl NetworkBehaviour for Behaviour { self.as_client().on_new_address(); } FromSwarm::ExpiredListenAddr(ExpiredListenAddr { listener_id, addr }) => { - self.inner - .on_swarm_event(FromSwarm::ExpiredListenAddr(ExpiredListenAddr { - listener_id, - addr, - })); + self.inner.on_swarm_event( + FromSwarm::ExpiredListenAddr(ExpiredListenAddr { listener_id, addr }) + ); self.as_client().on_expired_address(addr); } FromSwarm::ExternalAddrExpired(ExternalAddrExpired { addr }) => { @@ -576,10 +576,9 @@ impl NetworkBehaviour for Behaviour { self.as_client().on_expired_address(addr); } FromSwarm::NewExternalAddrCandidate(NewExternalAddrCandidate { addr }) => { - self.inner - .on_swarm_event(FromSwarm::NewExternalAddrCandidate( - NewExternalAddrCandidate { addr }, - )); + self.inner.on_swarm_event( + FromSwarm::NewExternalAddrCandidate(NewExternalAddrCandidate { addr }) + ); self.probe_address(addr.to_owned()); } listen_failure @ FromSwarm::ListenFailure(_) => { diff --git a/protocols/autonat/src/behaviour/as_client.rs b/protocols/autonat/src/behaviour/as_client.rs index 668f3b93719..ae8c7d845e3 100644 --- a/protocols/autonat/src/behaviour/as_client.rs +++ b/protocols/autonat/src/behaviour/as_client.rs @@ -244,9 +244,9 @@ impl<'a> AsClient<'a> { // Select a random server for the probe. fn random_server(&mut self) -> Option { // Update list of throttled servers. - let i = self.throttled_servers.partition_point(|(_, time)| { - *time + self.config.throttle_server_period < Instant::now() - }); + let i = self.throttled_servers.partition_point( + |(_, time)| *time + self.config.throttle_server_period < Instant::now() + ); self.throttled_servers.drain(..i); let mut servers: Vec<&PeerId> = self.servers.iter().collect(); @@ -281,13 +281,14 @@ impl<'a> AsClient<'a> { let server = self.random_server().ok_or(OutboundProbeError::NoServer)?; - let request_id = self.inner.send_request( - &server, - DialRequest { - peer_id: self.local_peer_id, - addresses, - }, - ); + let request_id = + self.inner.send_request( + &server, + DialRequest { + peer_id: self.local_peer_id, + addresses, + }, + ); self.throttled_servers.push((server, Instant::now())); tracing::debug!(peer=%server, "Send dial-back request to peer"); self.ongoing_outbound.insert(request_id, probe_id); diff --git a/protocols/autonat/src/behaviour/as_server.rs b/protocols/autonat/src/behaviour/as_server.rs index 878fd713dda..b91b5adab69 100644 --- a/protocols/autonat/src/behaviour/as_server.rs +++ b/protocols/autonat/src/behaviour/as_server.rs @@ -239,10 +239,12 @@ impl<'a> AsServer<'a> { "Dial-back to peer failed with error {:?}", error ), - None => tracing::debug!( - "Dial-back to non existent peer failed with error {:?}", - error - ), + None => { + tracing::debug!( + "Dial-back to non existent peer failed with error {:?}", + error + ) + } }; let response_error = ResponseError::DialError; @@ -266,9 +268,9 @@ impl<'a> AsServer<'a> { request: DialRequest, ) -> Result, (String, ResponseError)> { // Update list of throttled clients. - let i = self.throttled_clients.partition_point(|(_, time)| { - *time + self.config.throttle_clients_period < Instant::now() - }); + let i = self.throttled_clients.partition_point( + |(_, time)| *time + self.config.throttle_clients_period < Instant::now() + ); self.throttled_clients.drain(..i); if request.peer_id != sender { diff --git a/protocols/autonat/src/protocol.rs b/protocols/autonat/src/protocol.rs index c1862058400..4a1cb115833 100644 --- a/protocols/autonat/src/protocol.rs +++ b/protocols/autonat/src/protocol.rs @@ -137,16 +137,17 @@ impl DialRequest { .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "invalid peer id"))? }; - let addrs = addrs - .into_iter() - .filter_map(|a| match Multiaddr::try_from(a.to_vec()) { - Ok(a) => Some(a), - Err(e) => { - tracing::debug!("Unable to parse multiaddr: {e}"); - None - } - }) - .collect(); + let addrs = + addrs + .into_iter() + .filter_map(|a| match Multiaddr::try_from(a.to_vec()) { + Ok(a) => Some(a), + Err(e) => { + tracing::debug!("Unable to parse multiaddr: {e}"); + None + } + }) + .collect(); Ok(Self { peer_id, addresses: addrs, @@ -257,18 +258,19 @@ impl DialResponse { } pub fn into_proto(self) -> proto::Message { - let dial_response = match self.result { - Ok(addr) => proto::DialResponse { - status: Some(proto::ResponseStatus::OK), - statusText: self.status_text, - addr: Some(addr.to_vec()), - }, - Err(error) => proto::DialResponse { - status: Some(error.into()), - statusText: self.status_text, - addr: None, - }, - }; + let dial_response = + match self.result { + Ok(addr) => proto::DialResponse { + status: Some(proto::ResponseStatus::OK), + statusText: self.status_text, + addr: Some(addr.to_vec()), + }, + Err(error) => proto::DialResponse { + status: Some(error.into()), + statusText: self.status_text, + addr: None, + }, + }; proto::Message { type_pb: Some(proto::MessageType::DIAL_RESPONSE), @@ -298,10 +300,11 @@ mod tests { #[test] fn test_response_ok_encode_decode() { - let response = DialResponse { - result: Ok("/ip4/8.8.8.8/tcp/30333".parse().unwrap()), - status_text: None, - }; + let response = + DialResponse { + result: Ok("/ip4/8.8.8.8/tcp/30333".parse().unwrap()), + status_text: None, + }; let proto = response.clone().into_proto(); let response2 = DialResponse::from_proto(proto).unwrap(); assert_eq!(response, response2); @@ -323,11 +326,12 @@ mod tests { let valid_multiaddr: Multiaddr = "/ip6/2001:db8::/tcp/1234".parse().unwrap(); let valid_multiaddr_bytes = valid_multiaddr.to_vec(); - let invalid_multiaddr = { - let a = vec![255; 8]; - assert!(Multiaddr::try_from(a.clone()).is_err()); - a - }; + let invalid_multiaddr = + { + let a = vec![255; 8]; + assert!(Multiaddr::try_from(a.clone()).is_err()); + a + }; let msg = proto::Message { type_pb: Some(proto::MessageType::DIAL), diff --git a/protocols/autonat/tests/test_server.rs b/protocols/autonat/tests/test_server.rs index b0610ef59a4..8f3b4858aeb 100644 --- a/protocols/autonat/tests/test_server.rs +++ b/protocols/autonat/tests/test_server.rs @@ -168,10 +168,7 @@ async fn test_dial_error() { }) => { assert_eq!(probe_id, request_probe_id); assert_eq!(peer, client_id); - assert!(matches!( - error, - InboundProbeError::Response(ResponseError::DialError) - )); + assert!(matches!(error, InboundProbeError::Response(ResponseError::DialError))); } other => panic!("Unexpected behaviour event: {other:?}."), } diff --git a/protocols/dcutr/src/handler/relayed.rs b/protocols/dcutr/src/handler/relayed.rs index eba58f89313..54fdbc23ea8 100644 --- a/protocols/dcutr/src/handler/relayed.rs +++ b/protocols/dcutr/src/handler/relayed.rs @@ -134,10 +134,7 @@ impl Handler { ); if self .outbound_stream - .try_push(outbound::handshake( - stream, - self.holepunch_candidates.clone(), - )) + .try_push(outbound::handshake(stream, self.holepunch_candidates.clone())) .is_err() { tracing::warn!( @@ -170,10 +167,9 @@ impl Handler { StreamUpgradeError::Timeout => outbound::Error::Io(io::ErrorKind::TimedOut.into()), }; - self.queued_events - .push_back(ConnectionHandlerEvent::NotifyBehaviour( - Event::OutboundConnectFailed { error }, - )) + self.queued_events.push_back( + ConnectionHandlerEvent::NotifyBehaviour(Event::OutboundConnectFailed { error }) + ) } } @@ -242,9 +238,9 @@ impl ConnectionHandler for Handler { )) } Poll::Ready(Ok(Err(error))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::InboundConnectFailed { error }, - )) + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::InboundConnectFailed { error }) + ) } Poll::Ready(Err(futures_bounded::Timeout { .. })) => { return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( @@ -265,9 +261,9 @@ impl ConnectionHandler for Handler { )) } Poll::Ready(Ok(Err(error))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::OutboundConnectFailed { error }, - )) + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::OutboundConnectFailed { error }) + ) } Poll::Ready(Err(futures_bounded::Timeout { .. })) => { return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( diff --git a/protocols/dcutr/tests/lib.rs b/protocols/dcutr/tests/lib.rs index 9e1f0591e6d..d4a143df088 100644 --- a/protocols/dcutr/tests/lib.rs +++ b/protocols/dcutr/tests/lib.rs @@ -110,10 +110,9 @@ fn build_relay() -> Swarm { ..Default::default() }, ), - identify: identify::Behaviour::new(identify::Config::new( - "/relay".to_owned(), - identity.public(), - )), + identify: identify::Behaviour::new( + identify::Config::new("/relay".to_owned(), identity.public()) + ), } }) } @@ -144,10 +143,9 @@ fn build_client() -> Swarm { Client { relay: behaviour, dcutr: dcutr::Behaviour::new(local_peer_id), - identify: identify::Behaviour::new(identify::Config::new( - "/client".to_owned(), - local_key.public(), - )), + identify: identify::Behaviour::new( + identify::Config::new("/client".to_owned(), local_key.public()) + ), }, local_peer_id, Config::with_async_std_executor(), diff --git a/protocols/floodsub/src/layer.rs b/protocols/floodsub/src/layer.rs index 35711408a8d..a6f0472816e 100644 --- a/protocols/floodsub/src/layer.rs +++ b/protocols/floodsub/src/layer.rs @@ -230,9 +230,7 @@ impl Floodsub { } if self.config.subscribe_local_messages { self.events - .push_back(ToSwarm::GenerateEvent(FloodsubEvent::Message( - message.clone(), - ))); + .push_back(ToSwarm::GenerateEvent(FloodsubEvent::Message(message.clone()))); } } // Don't publish the message if we have to check subscriptions diff --git a/protocols/gossipsub/src/backoff.rs b/protocols/gossipsub/src/backoff.rs index b4a40b91a74..60c9925ceba 100644 --- a/protocols/gossipsub/src/backoff.rs +++ b/protocols/gossipsub/src/backoff.rs @@ -151,10 +151,11 @@ impl BackoffStorage { let slack = self.heartbeat_interval * self.backoff_slack; let now = Instant::now(); s.retain(|(topic, peer)| { - let keep = match Self::get_backoff_time_from_backoffs(backoffs, topic, peer) { - Some(backoff_time) => backoff_time + slack > now, - None => false, - }; + let keep = + match Self::get_backoff_time_from_backoffs(backoffs, topic, peer) { + Some(backoff_time) => backoff_time + slack > now, + None => false, + }; if !keep { //remove from backoffs if let Entry::Occupied(mut m) = backoffs.entry(topic.clone()) { diff --git a/protocols/gossipsub/src/behaviour.rs b/protocols/gossipsub/src/behaviour.rs index 0780ca657db..624c7d26552 100644 --- a/protocols/gossipsub/src/behaviour.rs +++ b/protocols/gossipsub/src/behaviour.rs @@ -536,15 +536,16 @@ where // send subscription request to all peers let peer_list = self.peer_topics.keys().cloned().collect::>(); if !peer_list.is_empty() { - let event = Rpc { - messages: Vec::new(), - subscriptions: vec![Subscription { - topic_hash: topic_hash.clone(), - action: SubscriptionAction::Subscribe, - }], - control_msgs: Vec::new(), - } - .into_protobuf(); + let event = + Rpc { + messages: Vec::new(), + subscriptions: vec![Subscription { + topic_hash: topic_hash.clone(), + action: SubscriptionAction::Subscribe, + }], + control_msgs: Vec::new(), + } + .into_protobuf(); for peer in peer_list { tracing::debug!(%peer, "Sending SUBSCRIBE to peer"); @@ -576,15 +577,16 @@ where // announce to all peers let peer_list = self.peer_topics.keys().cloned().collect::>(); if !peer_list.is_empty() { - let event = Rpc { - messages: Vec::new(), - subscriptions: vec![Subscription { - topic_hash: topic_hash.clone(), - action: SubscriptionAction::Unsubscribe, - }], - control_msgs: Vec::new(), - } - .into_protobuf(); + let event = + Rpc { + messages: Vec::new(), + subscriptions: vec![Subscription { + topic_hash: topic_hash.clone(), + action: SubscriptionAction::Unsubscribe, + }], + control_msgs: Vec::new(), + } + .into_protobuf(); for peer in peer_list { tracing::debug!(%peer, "Sending UNSUBSCRIBE to peer"); @@ -1360,12 +1362,13 @@ where .map(|message| message.topic.clone()) .collect::>(); - let message = Rpc { - subscriptions: Vec::new(), - messages: message_list, - control_msgs: Vec::new(), - } - .into_protobuf(); + let message = + Rpc { + subscriptions: Vec::new(), + messages: message_list, + control_msgs: Vec::new(), + } + .into_protobuf(); let msg_bytes = message.get_size(); @@ -2506,12 +2509,13 @@ where } // dynamic number of peers to gossip based on `gossip_factor` with minimum `gossip_lazy` - let n_map = |m| { - max( - self.config.gossip_lazy(), - (self.config.gossip_factor() * m as f64) as usize, - ) - }; + let n_map = + |m| { + max( + self.config.gossip_lazy(), + (self.config.gossip_factor() * m as f64) as usize, + ) + }; // get gossip_lazy random peers let to_msg_peers = get_random_peers_dynamic( &self.topic_peers, @@ -2578,12 +2582,13 @@ where &self.connected_peers, ); } - let mut control_msgs: Vec = topics - .iter() - .map(|topic_hash| ControlAction::Graft { - topic_hash: topic_hash.clone(), - }) - .collect(); + let mut control_msgs: Vec = + topics + .iter() + .map(|topic_hash| ControlAction::Graft { + topic_hash: topic_hash.clone(), + }) + .collect(); // If there are prunes associated with the same peer add them. // NOTE: In this case a peer has been added to a topic mesh, and removed from another. @@ -2718,12 +2723,13 @@ where // forward the message to peers if !recipient_peers.is_empty() { - let event = Rpc { - subscriptions: Vec::new(), - messages: vec![message.clone()], - control_msgs: Vec::new(), - } - .into_protobuf(); + let event = + Rpc { + subscriptions: Vec::new(), + messages: vec![message.clone()], + control_msgs: Vec::new(), + } + .into_protobuf(); let msg_bytes = event.get_size(); for peer in recipient_peers.iter() { @@ -2890,11 +2896,12 @@ where return Ok(vec![rpc]); } - let new_rpc = proto::RPC { - subscriptions: Vec::new(), - publish: Vec::new(), - control: None, - }; + let new_rpc = + proto::RPC { + subscriptions: Vec::new(), + publish: Vec::new(), + control: None, + }; let mut rpc_list = vec![new_rpc.clone()]; @@ -3469,14 +3476,15 @@ fn peer_added_to_mesh( connections: &HashMap, ) { // Ensure there is an active connection - let connection_id = { - let conn = connections.get(&peer_id).expect("To be connected to peer."); - assert!( - !conn.connections.is_empty(), - "Must have at least one connection" - ); - conn.connections[0] - }; + let connection_id = + { + let conn = connections.get(&peer_id).expect("To be connected to peer."); + assert!( + !conn.connections.is_empty(), + "Must have at least one connection" + ); + conn.connections[0] + }; if let Some(topics) = known_topics { for topic in topics { @@ -3717,11 +3725,12 @@ mod local_test { /// Tests RPC message fragmentation fn test_message_fragmentation_deterministic() { let max_transmit_size = 500; - let config = crate::config::ConfigBuilder::default() - .max_transmit_size(max_transmit_size) - .validation_mode(ValidationMode::Permissive) - .build() - .unwrap(); + let config = + crate::config::ConfigBuilder::default() + .max_transmit_size(max_transmit_size) + .validation_mode(ValidationMode::Permissive) + .build() + .unwrap(); let gs: Behaviour = Behaviour::new(MessageAuthenticity::RandomAuthor, config).unwrap(); // Message under the limit should be fine. diff --git a/protocols/gossipsub/src/behaviour/tests.rs b/protocols/gossipsub/src/behaviour/tests.rs index cf24ed8d8dc..9fc86b011fd 100644 --- a/protocols/gossipsub/src/behaviour/tests.rs +++ b/protocols/gossipsub/src/behaviour/tests.rs @@ -59,14 +59,15 @@ where pub(crate) fn create_network(self) -> (Behaviour, Vec, Vec) { let keypair = libp2p_identity::Keypair::generate_ed25519(); // create a gossipsub struct - let mut gs: Behaviour = Behaviour::new_with_subscription_filter_and_transform( - MessageAuthenticity::Signed(keypair), - self.gs_config, - None, - self.subscription_filter, - self.data_transform, - ) - .unwrap(); + let mut gs: Behaviour = + Behaviour::new_with_subscription_filter_and_transform( + MessageAuthenticity::Signed(keypair), + self.gs_config, + None, + self.subscription_filter, + self.data_transform, + ) + .unwrap(); if let Some((scoring_params, scoring_thresholds)) = self.scoring { gs.with_peer_score(scoring_params, scoring_thresholds) @@ -256,11 +257,12 @@ where F: TopicSubscriptionFilter + Clone + Default + Send + 'static, { if let Some(peer_connections) = gs.connected_peers.get(peer_id) { - let fake_endpoint = ConnectedPoint::Dialer { - address: Multiaddr::empty(), - role_override: Endpoint::Dialer, - }; // this is not relevant - // peer_connections.connections should never be empty. + let fake_endpoint = + ConnectedPoint::Dialer { + address: Multiaddr::empty(), + role_override: Endpoint::Dialer, + }; // this is not relevant + // peer_connections.connections should never be empty. let mut active_connections = peer_connections.connections.len(); for connection_id in peer_connections.connections.clone() { @@ -387,11 +389,12 @@ fn test_subscribe() { // - run JOIN(topic) let subscribe_topic = vec![String::from("test_subscribe")]; - let (gs, _, topic_hashes) = inject_nodes1() - .peer_no(20) - .topics(subscribe_topic) - .to_subscribe(true) - .create_network(); + let (gs, _, topic_hashes) = + inject_nodes1() + .peer_no(20) + .topics(subscribe_topic) + .to_subscribe(true) + .create_network(); assert!( gs.mesh.get(&topic_hashes[0]).is_some(), @@ -439,11 +442,12 @@ fn test_unsubscribe() { .collect::>(); // subscribe to topic_strings - let (mut gs, _, topic_hashes) = inject_nodes1() - .peer_no(20) - .topics(topic_strings) - .to_subscribe(true) - .create_network(); + let (mut gs, _, topic_hashes) = + inject_nodes1() + .peer_no(20) + .topics(topic_strings) + .to_subscribe(true) + .create_network(); for topic_hash in &topic_hashes { assert!( @@ -518,11 +522,12 @@ fn test_join() { .map(|t| Topic::new(t.clone())) .collect::>(); - let (mut gs, _, topic_hashes) = inject_nodes1() - .peer_no(20) - .topics(topic_strings) - .to_subscribe(true) - .create_network(); + let (mut gs, _, topic_hashes) = + inject_nodes1() + .peer_no(20) + .topics(topic_strings) + .to_subscribe(true) + .create_network(); // unsubscribe, then call join to invoke functionality assert!( @@ -951,18 +956,19 @@ fn test_get_random_peers() { gs.topic_peers .insert(topic_hash.clone(), peers.iter().cloned().collect()); - gs.connected_peers = peers - .iter() - .map(|p| { - ( - *p, - PeerConnections { - kind: PeerKind::Gossipsubv1_1, - connections: vec![ConnectionId::new_unchecked(0)], - }, - ) - }) - .collect(); + gs.connected_peers = + peers + .iter() + .map(|p| { + ( + *p, + PeerConnections { + kind: PeerKind::Gossipsubv1_1, + connections: vec![ConnectionId::new_unchecked(0)], + }, + ) + }) + .collect(); let random_peers = get_random_peers(&gs.topic_peers, &gs.connected_peers, &topic_hash, 5, |_| { @@ -1013,11 +1019,12 @@ fn test_get_random_peers() { /// Tests that the correct message is sent when a peer asks for a message in our cache. #[test] fn test_handle_iwant_msg_cached() { - let (mut gs, peers, _) = inject_nodes1() - .peer_no(20) - .topics(Vec::new()) - .to_subscribe(true) - .create_network(); + let (mut gs, peers, _) = + inject_nodes1() + .peer_no(20) + .topics(Vec::new()) + .to_subscribe(true) + .create_network(); let raw_message = RawMessage { source: Some(peers[11]), @@ -1069,11 +1076,12 @@ fn test_handle_iwant_msg_cached() { /// Tests that messages are sent correctly depending on the shifting of the message cache. #[test] fn test_handle_iwant_msg_cached_shifted() { - let (mut gs, peers, _) = inject_nodes1() - .peer_no(20) - .topics(Vec::new()) - .to_subscribe(true) - .create_network(); + let (mut gs, peers, _) = + inject_nodes1() + .peer_no(20) + .topics(Vec::new()) + .to_subscribe(true) + .create_network(); // perform 10 memshifts and check that it leaves the cache for shift in 1..10 { @@ -1134,11 +1142,12 @@ fn test_handle_iwant_msg_cached_shifted() { #[test] // tests that an event is not created when a peers asks for a message not in our cache fn test_handle_iwant_msg_not_cached() { - let (mut gs, peers, _) = inject_nodes1() - .peer_no(20) - .topics(Vec::new()) - .to_subscribe(true) - .create_network(); + let (mut gs, peers, _) = + inject_nodes1() + .peer_no(20) + .topics(Vec::new()) + .to_subscribe(true) + .create_network(); let events_before = gs.events.len(); gs.handle_iwant(&peers[7], vec![MessageId::new(b"unknown id")]); @@ -1165,15 +1174,18 @@ fn test_handle_ihave_subscribed_and_msg_not_cached() { ); // check that we sent an IWANT request for `unknown id` - let iwant_exists = match gs.control_pool.get(&peers[7]) { - Some(controls) => controls.iter().any(|c| match c { - ControlAction::IWant { message_ids } => message_ids - .iter() - .any(|m| *m == MessageId::new(b"unknown id")), + let iwant_exists = + match gs.control_pool.get(&peers[7]) { + Some(controls) => { + controls.iter().any(|c| match c { + ControlAction::IWant { message_ids } => message_ids + .iter() + .any(|m| *m == MessageId::new(b"unknown id")), + _ => false, + }) + } _ => false, - }), - _ => false, - }; + }; assert!( iwant_exists, @@ -1381,14 +1393,14 @@ fn test_explicit_peer_gets_connected() { //add peer as explicit peer gs.add_explicit_peer(&peer); - let num_events = gs - .events - .iter() - .filter(|e| match e { - ToSwarm::Dial { opts } => opts.get_peer_id() == Some(peer), - _ => false, - }) - .count(); + let num_events = + gs.events + .iter() + .filter(|e| match e { + ToSwarm::Dial { opts } => opts.get_peer_id() == Some(peer), + _ => false, + }) + .count(); assert_eq!( num_events, 1, @@ -1589,13 +1601,14 @@ fn do_forward_messages_to_explicit_peers() { #[test] fn explicit_peers_not_added_to_mesh_on_subscribe() { - let (mut gs, peers, _) = inject_nodes1() - .peer_no(2) - .topics(Vec::new()) - .to_subscribe(true) - .gs_config(Config::default()) - .explicit(1) - .create_network(); + let (mut gs, peers, _) = + inject_nodes1() + .peer_no(2) + .topics(Vec::new()) + .to_subscribe(true) + .gs_config(Config::default()) + .explicit(1) + .create_network(); //create new topic, both peers subscribing to it but we do not subscribe to it let topic = Topic::new(String::from("t")); @@ -1635,13 +1648,14 @@ fn explicit_peers_not_added_to_mesh_on_subscribe() { #[test] fn explicit_peers_not_added_to_mesh_from_fanout_on_subscribe() { - let (mut gs, peers, _) = inject_nodes1() - .peer_no(2) - .topics(Vec::new()) - .to_subscribe(true) - .gs_config(Config::default()) - .explicit(1) - .create_network(); + let (mut gs, peers, _) = + inject_nodes1() + .peer_no(2) + .topics(Vec::new()) + .to_subscribe(true) + .gs_config(Config::default()) + .explicit(1) + .create_network(); //create new topic, both peers subscribing to it but we do not subscribe to it let topic = Topic::new(String::from("t")); @@ -1767,13 +1781,14 @@ fn test_mesh_subtraction() { // Adds mesh_low peers and PRUNE 2 giving us a deficit. let n = config.mesh_n_high() + 10; //make all outbound connections so that we allow grafting to all - let (mut gs, peers, topics) = inject_nodes1() - .peer_no(n) - .topics(vec!["test".into()]) - .to_subscribe(true) - .gs_config(config.clone()) - .outbound(n) - .create_network(); + let (mut gs, peers, topics) = + inject_nodes1() + .peer_no(n) + .topics(vec!["test".into()]) + .to_subscribe(true) + .gs_config(config.clone()) + .outbound(n) + .create_network(); // graft all the peers for peer in peers { @@ -1791,11 +1806,12 @@ fn test_mesh_subtraction() { fn test_connect_to_px_peers_on_handle_prune() { let config: Config = Config::default(); - let (mut gs, peers, topics) = inject_nodes1() - .peer_no(1) - .topics(vec!["test".into()]) - .to_subscribe(true) - .create_network(); + let (mut gs, peers, topics) = + inject_nodes1() + .peer_no(1) + .topics(vec!["test".into()]) + .to_subscribe(true) + .create_network(); //handle prune from single peer with px peers @@ -1817,14 +1833,14 @@ fn test_connect_to_px_peers_on_handle_prune() { ); //Check DialPeer events for px peers - let dials: Vec<_> = gs - .events - .iter() - .filter_map(|e| match e { - ToSwarm::Dial { opts } => opts.get_peer_id(), - _ => None, - }) - .collect(); + let dials: Vec<_> = + gs.events + .iter() + .filter_map(|e| match e { + ToSwarm::Dial { opts } => opts.get_peer_id(), + _ => None, + }) + .collect(); // Exactly config.prune_peers() many random peers should be dialled assert_eq!(dials.len(), config.prune_peers()); @@ -1981,12 +1997,13 @@ fn test_do_not_graft_within_backoff_period() { #[test] fn test_do_not_graft_within_default_backoff_period_after_receiving_prune_without_backoff() { //set default backoff period to 1 second - let config = ConfigBuilder::default() - .prune_backoff(Duration::from_millis(90)) - .backoff_slack(1) - .heartbeat_interval(Duration::from_millis(100)) - .build() - .unwrap(); + let config = + ConfigBuilder::default() + .prune_backoff(Duration::from_millis(90)) + .backoff_slack(1) + .heartbeat_interval(Duration::from_millis(100)) + .build() + .unwrap(); //only one peer => mesh too small and will try to regraft as early as possible let (mut gs, peers, topics) = inject_nodes1() .peer_no(1) @@ -2202,11 +2219,12 @@ fn test_gossip_to_at_most_gossip_factor_peers() { //add a lot of peers let m = config.mesh_n_low() + config.gossip_lazy() * (2.0 / config.gossip_factor()) as usize; - let (mut gs, _, topic_hashes) = inject_nodes1() - .peer_no(m) - .topics(vec!["topic".into()]) - .to_subscribe(true) - .create_network(); + let (mut gs, _, topic_hashes) = + inject_nodes1() + .peer_no(m) + .topics(vec!["topic".into()]) + .to_subscribe(true) + .create_network(); //receive message let raw_message = RawMessage { @@ -2370,10 +2388,7 @@ fn test_prune_negative_scored_peers() { .gs_config(config.clone()) .explicit(0) .outbound(0) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); //add penalty to peer @@ -2413,10 +2428,7 @@ fn test_dont_graft_to_negative_scored_peers() { .topics(vec!["test".into()]) .to_subscribe(true) .gs_config(config) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); //add two additional peers that will not be part of the mesh @@ -2452,19 +2464,17 @@ fn test_ignore_px_from_negative_scored_peer() { .topics(vec!["test".into()]) .to_subscribe(true) .gs_config(config.clone()) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); //penalize peer gs.peer_score.as_mut().unwrap().0.add_penalty(&peers[0], 1); //handle prune from single peer with px peers - let px = vec![PeerInfo { - peer_id: Some(PeerId::random()), - }]; + let px = + vec![PeerInfo { + peer_id: Some(PeerId::random()), + }]; gs.handle_prune( &peers[0], @@ -2501,10 +2511,7 @@ fn test_only_send_nonnegative_scoring_peers_in_px() { .gs_config(config) .explicit(0) .outbound(0) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); // Penalize first peer @@ -2926,25 +2933,27 @@ fn test_ignore_rpc_from_peers_below_graylist_threshold() { //reduce score of p2 below publish_threshold but not below graylist_threshold gs.peer_score.as_mut().unwrap().0.add_penalty(&p2, 1); - let raw_message1 = RawMessage { - source: Some(PeerId::random()), - data: vec![1, 2, 3, 4], - sequence_number: Some(1u64), - topic: topics[0].clone(), - signature: None, - key: None, - validated: true, - }; + let raw_message1 = + RawMessage { + source: Some(PeerId::random()), + data: vec![1, 2, 3, 4], + sequence_number: Some(1u64), + topic: topics[0].clone(), + signature: None, + key: None, + validated: true, + }; - let raw_message2 = RawMessage { - source: Some(PeerId::random()), - data: vec![1, 2, 3, 4, 5], - sequence_number: Some(2u64), - topic: topics[0].clone(), - signature: None, - key: None, - validated: true, - }; + let raw_message2 = + RawMessage { + source: Some(PeerId::random()), + data: vec![1, 2, 3, 4, 5], + sequence_number: Some(2u64), + topic: topics[0].clone(), + signature: None, + key: None, + validated: true, + }; let raw_message3 = RawMessage { source: Some(PeerId::random()), @@ -3053,9 +3062,10 @@ fn test_ignore_px_from_peers_below_accept_px_threshold() { gs.set_application_score(&peers[1], 1.0); // Handle prune from peer peers[0] with px peers - let px = vec![PeerInfo { - peer_id: Some(PeerId::random()), - }]; + let px = + vec![PeerInfo { + peer_id: Some(PeerId::random()), + }]; gs.handle_prune( &peers[0], vec![( @@ -3075,9 +3085,10 @@ fn test_ignore_px_from_peers_below_accept_px_threshold() { ); //handle prune from peer peers[1] with px peers - let px = vec![PeerInfo { - peer_id: Some(PeerId::random()), - }]; + let px = + vec![PeerInfo { + peer_id: Some(PeerId::random()), + }]; gs.handle_prune( &peers[1], vec![( @@ -3116,10 +3127,7 @@ fn test_keep_best_scoring_peers_on_oversubscription() { .gs_config(config.clone()) .explicit(0) .outbound(n) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); // graft all, will be accepted since the are outbound @@ -4495,11 +4503,12 @@ fn test_ignore_too_many_ihaves() { #[test] fn test_ignore_too_many_messages_in_ihave() { - let config = ConfigBuilder::default() - .max_ihave_messages(10) - .max_ihave_length(10) - .build() - .unwrap(); + let config = + ConfigBuilder::default() + .max_ihave_messages(10) + .max_ihave_length(10) + .build() + .unwrap(); //build gossipsub with full mesh let (mut gs, _, topics) = inject_nodes1() .peer_no(config.mesh_n_high()) @@ -4575,11 +4584,12 @@ fn test_ignore_too_many_messages_in_ihave() { #[test] fn test_limit_number_of_message_ids_inside_ihave() { - let config = ConfigBuilder::default() - .max_ihave_messages(10) - .max_ihave_length(100) - .build() - .unwrap(); + let config = + ConfigBuilder::default() + .max_ihave_messages(10) + .max_ihave_length(100) + .build() + .unwrap(); //build gossipsub with full mesh let (mut gs, peers, topics) = inject_nodes1() .peer_no(config.mesh_n_high()) @@ -4928,11 +4938,12 @@ fn test_dont_add_floodsub_peers_to_mesh_on_join() { #[test] fn test_dont_send_px_to_old_gossipsub_peers() { - let (mut gs, _, topics) = inject_nodes1() - .peer_no(0) - .topics(vec!["test".into()]) - .to_subscribe(false) - .create_network(); + let (mut gs, _, topics) = + inject_nodes1() + .peer_no(0) + .topics(vec!["test".into()]) + .to_subscribe(false) + .create_network(); //add an old gossipsub peer let p1 = add_peer_with_addr_and_kind( @@ -4965,11 +4976,12 @@ fn test_dont_send_px_to_old_gossipsub_peers() { #[test] fn test_dont_send_floodsub_peers_in_px() { //build mesh with one peer - let (mut gs, peers, topics) = inject_nodes1() - .peer_no(1) - .topics(vec!["test".into()]) - .to_subscribe(true) - .create_network(); + let (mut gs, peers, topics) = + inject_nodes1() + .peer_no(1) + .topics(vec!["test".into()]) + .to_subscribe(true) + .create_network(); //add two floodsub peers let _p1 = add_peer_with_addr_and_kind( @@ -5002,11 +5014,12 @@ fn test_dont_send_floodsub_peers_in_px() { #[test] fn test_dont_add_floodsub_peers_to_mesh_in_heartbeat() { - let (mut gs, _, topics) = inject_nodes1() - .peer_no(0) - .topics(vec!["test".into()]) - .to_subscribe(false) - .create_network(); + let (mut gs, _, topics) = + inject_nodes1() + .peer_no(0) + .topics(vec!["test".into()]) + .to_subscribe(false) + .create_network(); //add two floodsub peer, one explicit, one implicit let _p1 = add_peer_with_addr_and_kind( @@ -5062,12 +5075,11 @@ fn test_public_api() { fn test_subscribe_to_invalid_topic() { let t1 = Topic::new("t1"); let t2 = Topic::new("t2"); - let (mut gs, _, _) = inject_nodes::() - .subscription_filter(WhitelistSubscriptionFilter( - vec![t1.hash()].into_iter().collect(), - )) - .to_subscribe(false) - .create_network(); + let (mut gs, _, _) = + inject_nodes::() + .subscription_filter(WhitelistSubscriptionFilter(vec![t1.hash()].into_iter().collect())) + .to_subscribe(false) + .create_network(); assert!(gs.subscribe(&t1).is_ok()); assert!(gs.subscribe(&t2).is_err()); @@ -5078,10 +5090,7 @@ fn test_subscribe_and_graft_with_negative_score() { //simulate a communication between two gossipsub instances let (mut gs1, _, topic_hashes) = inject_nodes1() .topics(vec!["test".into()]) - .scoring(Some(( - PeerScoreParams::default(), - PeerScoreThresholds::default(), - ))) + .scoring(Some((PeerScoreParams::default(), PeerScoreThresholds::default()))) .create_network(); let (mut gs2, _, _) = inject_nodes1().create_network(); @@ -5101,33 +5110,34 @@ fn test_subscribe_and_graft_with_negative_score() { //subscribe to topic in gs2 gs2.subscribe(&topic).unwrap(); - let forward_messages_to_p1 = |gs1: &mut Behaviour<_, _>, gs2: &mut Behaviour<_, _>| { - //collect messages to p1 - let messages_to_p1 = gs2.events.drain(..).filter_map(|e| match e { - ToSwarm::NotifyHandler { peer_id, event, .. } => { - if peer_id == p1 { - if let HandlerIn::Message(m) = event { - Some(m) + let forward_messages_to_p1 = + |gs1: &mut Behaviour<_, _>, gs2: &mut Behaviour<_, _>| { + //collect messages to p1 + let messages_to_p1 = gs2.events.drain(..).filter_map(|e| match e { + ToSwarm::NotifyHandler { peer_id, event, .. } => { + if peer_id == p1 { + if let HandlerIn::Message(m) = event { + Some(m) + } else { + None + } } else { None } - } else { - None } + _ => None, + }); + for message in messages_to_p1 { + gs1.on_connection_handler_event( + p2, + connection_id, + HandlerEvent::Message { + rpc: proto_to_message(&message), + invalid_messages: vec![], + }, + ); } - _ => None, - }); - for message in messages_to_p1 { - gs1.on_connection_handler_event( - p2, - connection_id, - HandlerEvent::Message { - rpc: proto_to_message(&message), - invalid_messages: vec![], - }, - ); - } - }; + }; //forward the subscribe message forward_messages_to_p1(&mut gs1, &mut gs2); @@ -5154,11 +5164,12 @@ fn test_graft_without_subscribe() { let topic = String::from("test_subscribe"); let subscribe_topic = vec![topic.clone()]; let subscribe_topic_hash = vec![Topic::new(topic.clone()).hash()]; - let (mut gs, peers, topic_hashes) = inject_nodes1() - .peer_no(1) - .topics(subscribe_topic) - .to_subscribe(false) - .create_network(); + let (mut gs, peers, topic_hashes) = + inject_nodes1() + .peer_no(1) + .topics(subscribe_topic) + .to_subscribe(false) + .create_network(); assert!( gs.mesh.get(&topic_hashes[0]).is_some(), diff --git a/protocols/gossipsub/src/config.rs b/protocols/gossipsub/src/config.rs index 7e79912cc4a..602484103ec 100644 --- a/protocols/gossipsub/src/config.rs +++ b/protocols/gossipsub/src/config.rs @@ -869,10 +869,11 @@ mod test { #[test] fn create_config_with_message_id_as_plain_function() { - let config = ConfigBuilder::default() - .message_id_fn(message_id_plain_function) - .build() - .unwrap(); + let config = + ConfigBuilder::default() + .message_id_fn(message_id_plain_function) + .build() + .unwrap(); let result = config.message_id(&get_gossipsub_message()); diff --git a/protocols/gossipsub/src/handler.rs b/protocols/gossipsub/src/handler.rs index e2ec681321c..1849bf6e519 100644 --- a/protocols/gossipsub/src/handler.rs +++ b/protocols/gossipsub/src/handler.rs @@ -487,10 +487,9 @@ impl ConnectionHandler for Handler { } match event { - ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { - protocol, - .. - }) => match protocol { + ConnectionEvent::FullyNegotiatedInbound( + FullyNegotiatedInbound { protocol, .. } + ) => match protocol { Either::Left(protocol) => handler.on_fully_negotiated_inbound(protocol), Either::Right(v) => void::unreachable(v), }, diff --git a/protocols/gossipsub/src/mcache.rs b/protocols/gossipsub/src/mcache.rs index ef4a93bc936..82596b574e3 100644 --- a/protocols/gossipsub/src/mcache.rs +++ b/protocols/gossipsub/src/mcache.rs @@ -158,22 +158,24 @@ impl MessageCache { .iter() .fold(vec![], |mut current_entries, entries| { // search for entries with desired topic - let mut found_entries: Vec = entries - .iter() - .filter_map(|entry| { - if &entry.topic == topic { - let mid = &entry.mid; - // Only gossip validated messages - if let Some(true) = self.msgs.get(mid).map(|(msg, _)| msg.validated) { - Some(mid.clone()) + let mut found_entries: Vec = + entries + .iter() + .filter_map(|entry| { + if &entry.topic == topic { + let mid = &entry.mid; + // Only gossip validated messages + if let Some(true) = self.msgs.get(mid).map(|(msg, _)| msg.validated) + { + Some(mid.clone()) + } else { + None + } } else { None } - } else { - None - } - }) - .collect(); + }) + .collect(); // generate the list current_entries.append(&mut found_entries); diff --git a/protocols/gossipsub/src/metrics.rs b/protocols/gossipsub/src/metrics.rs index e044ca67e71..a65c7802e28 100644 --- a/protocols/gossipsub/src/metrics.rs +++ b/protocols/gossipsub/src/metrics.rs @@ -56,17 +56,18 @@ pub struct Config { impl Config { /// Create buckets for the score histograms based on score thresholds. pub fn buckets_using_scoring_thresholds(&mut self, params: &crate::PeerScoreThresholds) { - self.score_buckets = vec![ - params.graylist_threshold, - params.publish_threshold, - params.gossip_threshold, - params.gossip_threshold / 2.0, - params.gossip_threshold / 4.0, - 0.0, - 1.0, - 10.0, - 100.0, - ]; + self.score_buckets = + vec![ + params.graylist_threshold, + params.publish_threshold, + params.gossip_threshold, + params.gossip_threshold / 2.0, + params.gossip_threshold / 4.0, + 0.0, + 1.0, + 10.0, + 100.0, + ]; } } @@ -76,17 +77,18 @@ impl Default for Config { let gossip_threshold = -4000.0; let publish_threshold = -8000.0; let graylist_threshold = -16000.0; - let score_buckets: Vec = vec![ - graylist_threshold, - publish_threshold, - gossip_threshold, - gossip_threshold / 2.0, - gossip_threshold / 4.0, - 0.0, - 1.0, - 10.0, - 100.0, - ]; + let score_buckets: Vec = + vec![ + graylist_threshold, + publish_threshold, + gossip_threshold, + gossip_threshold / 2.0, + gossip_threshold / 4.0, + 0.0, + 1.0, + 10.0, + 100.0, + ]; Config { max_topics: DEFAULT_MAX_TOPICS, max_never_subscribed_topics: DEFAULT_MAX_NEVER_SUBSCRIBED_TOPICS, @@ -261,9 +263,10 @@ impl Metrics { "Bytes received from gossip messages for each topic" ); - let hist_builder = HistBuilder { - buckets: score_buckets, - }; + let hist_builder = + HistBuilder { + buckets: score_buckets, + }; let score_per_mesh: Family<_, _, HistBuilder> = Family::new_with_constructor(hist_builder); registry.register( diff --git a/protocols/gossipsub/src/peer_score.rs b/protocols/gossipsub/src/peer_score.rs index b1ea9bfae95..cdf650472c0 100644 --- a/protocols/gossipsub/src/peer_score.rs +++ b/protocols/gossipsub/src/peer_score.rs @@ -236,27 +236,29 @@ impl PeerScore { // P1: time in mesh if let MeshStatus::Active { mesh_time, .. } = topic_stats.mesh_status { - let p1 = { - let v = mesh_time.as_secs_f64() - / topic_params.time_in_mesh_quantum.as_secs_f64(); - if v < topic_params.time_in_mesh_cap { - v - } else { - topic_params.time_in_mesh_cap - } - }; + let p1 = + { + let v = mesh_time.as_secs_f64() + / topic_params.time_in_mesh_quantum.as_secs_f64(); + if v < topic_params.time_in_mesh_cap { + v + } else { + topic_params.time_in_mesh_cap + } + }; topic_score += p1 * topic_params.time_in_mesh_weight; } // P2: first message deliveries - let p2 = { - let v = topic_stats.first_message_deliveries; - if v < topic_params.first_message_deliveries_cap { - v - } else { - topic_params.first_message_deliveries_cap - } - }; + let p2 = + { + let v = topic_stats.first_message_deliveries; + if v < topic_params.first_message_deliveries_cap { + v + } else { + topic_params.first_message_deliveries_cap + } + }; topic_score += p2 * topic_params.first_message_deliveries_weight; // P3: mesh message deliveries @@ -643,28 +645,29 @@ impl PeerScore { _ => {} // the rest are handled after record creation } - let peers: Vec<_> = { - let record = self.deliveries.entry(msg_id.clone()).or_default(); + let peers: Vec<_> = + { + let record = self.deliveries.entry(msg_id.clone()).or_default(); - // Multiple peers can now reject the same message as we track which peers send us the - // message. If we have already updated the status, return. - if record.status != DeliveryStatus::Unknown { - return; - } + // Multiple peers can now reject the same message as we track which peers send us the + // message. If we have already updated the status, return. + if record.status != DeliveryStatus::Unknown { + return; + } - if let RejectReason::ValidationIgnored = reason { - // we were explicitly instructed by the validator to ignore the message but not penalize - // the peer - record.status = DeliveryStatus::Ignored; - record.peers.clear(); - return; - } + if let RejectReason::ValidationIgnored = reason { + // we were explicitly instructed by the validator to ignore the message but not penalize + // the peer + record.status = DeliveryStatus::Ignored; + record.peers.clear(); + return; + } - // mark the message as invalid and penalize peers that have already forwarded it. - record.status = DeliveryStatus::Invalid; - // release the delivery time tracking map to free some memory early - record.peers.drain().collect() - }; + // mark the message as invalid and penalize peers that have already forwarded it. + record.status = DeliveryStatus::Invalid; + // release the delivery time tracking map to free some memory early + record.peers.drain().collect() + }; self.mark_invalid_message_delivery(from, topic_hash); for peer_id in peers.iter() { @@ -806,12 +809,14 @@ impl PeerScore { .get(topic_hash) .expect("Topic must exist if there are known topic_stats") .first_message_deliveries_cap; - topic_stats.first_message_deliveries = - if topic_stats.first_message_deliveries + 1f64 > cap { - cap - } else { - topic_stats.first_message_deliveries + 1f64 - }; + topic_stats.first_message_deliveries = if topic_stats.first_message_deliveries + + 1f64 + > cap + { + cap + } else { + topic_stats.first_message_deliveries + 1f64 + }; if let MeshStatus::Active { .. } = topic_stats.mesh_status { let cap = self @@ -821,12 +826,14 @@ impl PeerScore { .expect("Topic must exist if there are known topic_stats") .mesh_message_deliveries_cap; - topic_stats.mesh_message_deliveries = - if topic_stats.mesh_message_deliveries + 1f64 > cap { - cap - } else { - topic_stats.mesh_message_deliveries + 1f64 - }; + topic_stats.mesh_message_deliveries = if topic_stats.mesh_message_deliveries + + 1f64 + > cap + { + cap + } else { + topic_stats.mesh_message_deliveries + 1f64 + }; } } } @@ -841,11 +848,12 @@ impl PeerScore { validated_time: Option, ) { if let Some(peer_stats) = self.peer_stats.get_mut(peer_id) { - let now = if validated_time.is_some() { - Some(Instant::now()) - } else { - None - }; + let now = + if validated_time.is_some() { + Some(Instant::now()) + } else { + None + }; if let Some(topic_stats) = peer_stats.stats_or_default_mut(topic_hash.clone(), &self.params) { @@ -874,12 +882,14 @@ impl PeerScore { if falls_in_mesh_deliver_window { let cap = topic_params.mesh_message_deliveries_cap; - topic_stats.mesh_message_deliveries = - if topic_stats.mesh_message_deliveries + 1f64 > cap { - cap - } else { - topic_stats.mesh_message_deliveries + 1f64 - }; + topic_stats.mesh_message_deliveries = if topic_stats.mesh_message_deliveries + + 1f64 + > cap + { + cap + } else { + topic_stats.mesh_message_deliveries + 1f64 + }; } } } diff --git a/protocols/gossipsub/src/peer_score/tests.rs b/protocols/gossipsub/src/peer_score/tests.rs index 064e277eed7..2fc9adbf53e 100644 --- a/protocols/gossipsub/src/peer_score/tests.rs +++ b/protocols/gossipsub/src/peer_score/tests.rs @@ -870,11 +870,12 @@ fn test_score_behaviour_penality() { let topic = Topic::new("test"); let topic_hash = topic.hash(); - let mut params = PeerScoreParams { - behaviour_penalty_decay, - behaviour_penalty_weight, - ..Default::default() - }; + let mut params = + PeerScoreParams { + behaviour_penalty_decay, + behaviour_penalty_weight, + ..Default::default() + }; let topic_params = TopicScoreParams { topic_weight: 1.0, diff --git a/protocols/gossipsub/src/protocol.rs b/protocols/gossipsub/src/protocol.rs index 42d43c97510..2a3e38eb79c 100644 --- a/protocols/gossipsub/src/protocol.rs +++ b/protocols/gossipsub/src/protocol.rs @@ -363,36 +363,38 @@ impl Decoder for GossipsubCodec { }; // Verify the message source if required - let source = if verify_source { - if let Some(bytes) = message.from { - if !bytes.is_empty() { - match PeerId::from_bytes(&bytes) { - Ok(peer_id) => Some(peer_id), // valid peer id - Err(_) => { - // invalid peer id, add to invalid messages - tracing::debug!("Message source has an invalid PeerId"); - let message = RawMessage { - source: None, // don't bother inform the application - data: message.data.unwrap_or_default(), - sequence_number, - topic: TopicHash::from_raw(message.topic), - signature: message.signature, // don't inform the application - key: message.key, - validated: false, - }; - invalid_messages.push((message, ValidationError::InvalidPeerId)); - continue; + let source = + if verify_source { + if let Some(bytes) = message.from { + if !bytes.is_empty() { + match PeerId::from_bytes(&bytes) { + Ok(peer_id) => Some(peer_id), // valid peer id + Err(_) => { + // invalid peer id, add to invalid messages + tracing::debug!("Message source has an invalid PeerId"); + let message = RawMessage { + source: None, // don't bother inform the application + data: message.data.unwrap_or_default(), + sequence_number, + topic: TopicHash::from_raw(message.topic), + signature: message.signature, // don't inform the application + key: message.key, + validated: false, + }; + invalid_messages + .push((message, ValidationError::InvalidPeerId)); + continue; + } } + } else { + None } } else { None } } else { None - } - } else { - None - }; + }; // This message has passed all validation, add it to the validated messages. messages.push(RawMessage { @@ -423,25 +425,27 @@ impl Decoder for GossipsubCodec { }) .collect(); - let iwant_msgs: Vec = rpc_control - .iwant - .into_iter() - .map(|iwant| ControlAction::IWant { - message_ids: iwant - .message_ids - .into_iter() - .map(MessageId::from) - .collect::>(), - }) - .collect(); + let iwant_msgs: Vec = + rpc_control + .iwant + .into_iter() + .map(|iwant| ControlAction::IWant { + message_ids: iwant + .message_ids + .into_iter() + .map(MessageId::from) + .collect::>(), + }) + .collect(); - let graft_msgs: Vec = rpc_control - .graft - .into_iter() - .map(|graft| ControlAction::Graft { - topic_hash: TopicHash::from_raw(graft.topic_id.unwrap_or_default()), - }) - .collect(); + let graft_msgs: Vec = + rpc_control + .graft + .into_iter() + .map(|graft| ControlAction::Graft { + topic_hash: TopicHash::from_raw(graft.topic_id.unwrap_or_default()), + }) + .collect(); let mut prune_msgs = Vec::new(); @@ -602,12 +606,13 @@ mod tests { #[test] fn support_floodsub_with_custom_protocol() { - let protocol_config = ConfigBuilder::default() - .protocol_id("/foosub", Version::V1_1) - .support_floodsub() - .build() - .unwrap() - .protocol_config(); + let protocol_config = + ConfigBuilder::default() + .protocol_id("/foosub", Version::V1_1) + .support_floodsub() + .build() + .unwrap() + .protocol_config(); assert_eq!(protocol_config.protocol_ids[0].protocol, "/foosub"); assert_eq!(protocol_config.protocol_ids[1].protocol, "/floodsub/1.0.0"); diff --git a/protocols/gossipsub/src/subscription_filter.rs b/protocols/gossipsub/src/subscription_filter.rs index 09c323d7904..c0b6f9c77e2 100644 --- a/protocols/gossipsub/src/subscription_filter.rs +++ b/protocols/gossipsub/src/subscription_filter.rs @@ -259,16 +259,17 @@ mod test { let mut filter = WhitelistSubscriptionFilter(HashSet::from_iter(vec![t1.clone()])); let old = Default::default(); - let subscriptions = vec![ - Subscription { - action: Subscribe, - topic_hash: t1, - }, - Subscription { - action: Subscribe, - topic_hash: t2, - }, - ]; + let subscriptions = + vec![ + Subscription { + action: Subscribe, + topic_hash: t1, + }, + Subscription { + action: Subscribe, + topic_hash: t2, + }, + ]; let result = filter .filter_incoming_subscriptions(&subscriptions, &old) @@ -387,16 +388,17 @@ mod test { let mut filter = CallbackSubscriptionFilter(|h| h.as_str() == "t1"); let old = Default::default(); - let subscriptions = vec![ - Subscription { - action: Subscribe, - topic_hash: t1, - }, - Subscription { - action: Subscribe, - topic_hash: t2, - }, - ]; + let subscriptions = + vec![ + Subscription { + action: Subscribe, + topic_hash: t1, + }, + Subscription { + action: Subscribe, + topic_hash: t2, + }, + ]; let result = filter .filter_incoming_subscriptions(&subscriptions, &old) diff --git a/protocols/gossipsub/src/topic.rs b/protocols/gossipsub/src/topic.rs index a73496b53f2..b9279d30e07 100644 --- a/protocols/gossipsub/src/topic.rs +++ b/protocols/gossipsub/src/topic.rs @@ -49,11 +49,12 @@ impl Hasher for Sha256Hash { fn hash(topic_string: String) -> TopicHash { use quick_protobuf::MessageWrite; - let topic_descripter = proto::TopicDescriptor { - name: Some(topic_string), - auth: None, - enc: None, - }; + let topic_descripter = + proto::TopicDescriptor { + name: Some(topic_string), + auth: None, + enc: None, + }; let mut bytes = Vec::with_capacity(topic_descripter.get_size()); let mut writer = Writer::new(&mut bytes); topic_descripter diff --git a/protocols/identify/src/behaviour.rs b/protocols/identify/src/behaviour.rs index e4da898f44c..070f08ecf92 100644 --- a/protocols/identify/src/behaviour.rs +++ b/protocols/identify/src/behaviour.rs @@ -359,11 +359,12 @@ impl NetworkBehaviour for Behaviour { if listen_addr_changed && self.config.push_listen_addr_updates { // trigger an identify push for all connected peers - let push_events = self.connected.keys().map(|peer| ToSwarm::NotifyHandler { - peer_id: *peer, - handler: NotifyHandler::Any, - event: InEvent::Push, - }); + let push_events = + self.connected.keys().map(|peer| ToSwarm::NotifyHandler { + peer_id: *peer, + handler: NotifyHandler::Any, + event: InEvent::Push, + }); self.events.extend(push_events); } diff --git a/protocols/identify/src/handler.rs b/protocols/identify/src/handler.rs index f9b77e0b63a..43a2f3cef24 100644 --- a/protocols/identify/src/handler.rs +++ b/protocols/identify/src/handler.rs @@ -52,13 +52,14 @@ const MAX_CONCURRENT_STREAMS_PER_CONNECTION: usize = 10; pub struct Handler { remote_peer_id: PeerId, /// Pending events to yield. - events: SmallVec< - [ConnectionHandlerEvent< - Either, ReadyUpgrade>, - (), - Event, - >; 4], - >, + events: + SmallVec< + [ConnectionHandlerEvent< + Either, ReadyUpgrade>, + (), + Event, + >; 4], + >, active_streams: futures_bounded::FuturesSet>, @@ -339,28 +340,26 @@ impl ConnectionHandler for Handler { Poll::Ready(Ok(Ok(Success::ReceivedIdentify(remote_info)))) => { self.handle_incoming_info(&remote_info); - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Event::Identified( - remote_info, - ))); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::Identified(remote_info)) + ); } Poll::Ready(Ok(Ok(Success::SentIdentifyPush(info)))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::IdentificationPushed(info), - )); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::IdentificationPushed(info)) + ); } Poll::Ready(Ok(Ok(Success::SentIdentify))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::Identification, - )); + return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Event::Identification)); } Poll::Ready(Ok(Ok(Success::ReceivedIdentifyPush(remote_push_info)))) => { if let Some(mut info) = self.remote_info.clone() { info.merge(remote_push_info); self.handle_incoming_info(&info); - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::Identified(info), - )); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::Identified(info)) + ); }; } Poll::Ready(Ok(Err(e))) => { diff --git a/protocols/identify/src/protocol.rs b/protocols/identify/src/protocol.rs index c6b22b00c0a..48fc8538957 100644 --- a/protocols/identify/src/protocol.rs +++ b/protocols/identify/src/protocol.rs @@ -150,13 +150,14 @@ where // remote's ACK, but it could be that the remote already dropped the stream // after finishing their write. - let info = FramedRead::new( - socket, - quick_protobuf_codec::Codec::::new(MAX_MESSAGE_SIZE_BYTES), - ) - .next() - .await - .ok_or(UpgradeError::StreamClosed)??; + let info = + FramedRead::new( + socket, + quick_protobuf_codec::Codec::::new(MAX_MESSAGE_SIZE_BYTES), + ) + .next() + .await + .ok_or(UpgradeError::StreamClosed)??; Ok(info) } @@ -273,11 +274,12 @@ mod tests { let valid_multiaddr: Multiaddr = "/ip6/2001:db8::/tcp/1234".parse().unwrap(); let valid_multiaddr_bytes = valid_multiaddr.to_vec(); - let invalid_multiaddr = { - let a = vec![255; 8]; - assert!(Multiaddr::try_from(a.clone()).is_err()); - a - }; + let invalid_multiaddr = + { + let a = vec![255; 8]; + assert!(Multiaddr::try_from(a.clone()).is_err()); + a + }; let payload = proto::Identify { agentVersion: None, diff --git a/protocols/identify/tests/smoke.rs b/protocols/identify/tests/smoke.rs index 5cccc09d863..ffc46110089 100644 --- a/protocols/identify/tests/smoke.rs +++ b/protocols/identify/tests/smoke.rs @@ -109,10 +109,11 @@ async fn only_emits_address_candidate_once_per_connection() { async_std::task::spawn(swarm2.loop_on_next()); - let swarm_events = futures::stream::poll_fn(|cx| swarm1.poll_next_unpin(cx)) - .take(5) - .collect::>() - .await; + let swarm_events = + futures::stream::poll_fn(|cx| swarm1.poll_next_unpin(cx)) + .take(5) + .collect::>() + .await; let infos = swarm_events .iter() diff --git a/protocols/kad/src/behaviour.rs b/protocols/kad/src/behaviour.rs index 5a4b737c998..10f12613486 100644 --- a/protocols/kad/src/behaviour.rs +++ b/protocols/kad/src/behaviour.rs @@ -686,19 +686,20 @@ where /// The result of this operation is delivered in a /// [`Event::OutboundQueryProgressed{QueryResult::GetRecord}`]. pub fn get_record(&mut self, key: record::Key) -> QueryId { - let record = if let Some(record) = self.store.get(&key) { - if record.is_expired(Instant::now()) { - self.store.remove(&key); - None + let record = + if let Some(record) = self.store.get(&key) { + if record.is_expired(Instant::now()) { + self.store.remove(&key); + None + } else { + Some(PeerRecord { + peer: None, + record: record.into_owned(), + }) + } } else { - Some(PeerRecord { - peer: None, - record: record.into_owned(), - }) - } - } else { - None - }; + None + }; let step = ProgressStep::first(); @@ -943,25 +944,26 @@ where /// The result of this operation is delivered in a /// reported via [`Event::OutboundQueryProgressed{QueryResult::GetProviders}`]. pub fn get_providers(&mut self, key: record::Key) -> QueryId { - let providers: HashSet<_> = self - .store - .providers(&key) - .into_iter() - .filter(|p| !p.is_expired(Instant::now())) - .map(|p| p.provider) - .collect(); + let providers: HashSet<_> = + self.store + .providers(&key) + .into_iter() + .filter(|p| !p.is_expired(Instant::now())) + .map(|p| p.provider) + .collect(); let step = ProgressStep::first(); - let info = QueryInfo::GetProviders { - key: key.clone(), - providers_found: providers.len(), - step: if providers.is_empty() { - step.clone() - } else { - step.next() - }, - }; + let info = + QueryInfo::GetProviders { + key: key.clone(), + providers_found: providers.len(), + step: if providers.is_empty() { + step.clone() + } else { + step.next() + }, + }; let target = kbucket::Key::new(key.clone()); let peers = self.kbuckets.closest_keys(&target); @@ -975,10 +977,9 @@ where self.queued_events .push_back(ToSwarm::GenerateEvent(Event::OutboundQueryProgressed { id, - result: QueryResult::GetProviders(Ok(GetProvidersOk::FoundProviders { - key, - providers, - })), + result: QueryResult::GetProviders( + Ok(GetProvidersOk::FoundProviders { key, providers }) + ), step, stats, })); @@ -1263,11 +1264,9 @@ where .push_back(ToSwarm::GenerateEvent(Event::UnroutablePeer { peer })); } (Some(a), BucketInserts::Manual) => { - self.queued_events - .push_back(ToSwarm::GenerateEvent(Event::RoutablePeer { - peer, - address: a, - })); + self.queued_events.push_back( + ToSwarm::GenerateEvent(Event::RoutablePeer { peer, address: a }) + ); } (Some(a), BucketInserts::OnConnected) => { let addresses = Addresses::new(a); @@ -1503,15 +1502,16 @@ where quorum, phase: PutRecordPhase::GetClosestPeers, } => { - let info = QueryInfo::PutRecord { - context, - record, - quorum, - phase: PutRecordPhase::PutRecord { - success: vec![], - get_closest_peers_stats: result.stats, - }, - }; + let info = + QueryInfo::PutRecord { + context, + record, + quorum, + phase: PutRecordPhase::PutRecord { + success: vec![], + get_closest_peers_stats: result.stats, + }, + }; let inner = QueryInner::new(info); self.queries.continue_fixed(query_id, result.peers, inner); None @@ -2131,14 +2131,15 @@ where // We should order addresses from decreasing likelyhood of connectivity, so start with // the addresses of that peer in the k-buckets. let key = kbucket::Key::from(peer_id); - let mut peer_addrs = - if let kbucket::Entry::Present(mut entry, _) = self.kbuckets.entry(&key) { - let addrs = entry.value().iter().cloned().collect::>(); - debug_assert!(!addrs.is_empty(), "Empty peer addresses in routing table."); - addrs - } else { - Vec::new() - }; + let mut peer_addrs = if let kbucket::Entry::Present(mut entry, _) = + self.kbuckets.entry(&key) + { + let addrs = entry.value().iter().cloned().collect::>(); + debug_assert!(!addrs.is_empty(), "Empty peer addresses in routing table."); + addrs + } else { + Vec::new() + }; // We add to that a temporary list of addresses from the ongoing queries. for query in self.queries.iter() { @@ -2347,9 +2348,9 @@ where self.queued_events.push_back(ToSwarm::GenerateEvent( Event::OutboundQueryProgressed { id: query_id, - result: QueryResult::GetRecord(Ok(GetRecordOk::FoundRecord( - record, - ))), + result: QueryResult::GetRecord( + Ok(GetRecordOk::FoundRecord(record)) + ), step: step.clone(), stats, }, @@ -2443,12 +2444,13 @@ where let num = usize::min(JOBS_MAX_NEW_QUERIES, jobs_query_capacity); for _ in 0..num { if let Poll::Ready(r) = job.poll(cx, &mut self.store, now) { - let context = - if r.publisher.as_ref() == Some(self.kbuckets.local_key().preimage()) { - PutRecordContext::Republish - } else { - PutRecordContext::Replicate - }; + let context = if r.publisher.as_ref() + == Some(self.kbuckets.local_key().preimage()) + { + PutRecordContext::Republish + } else { + PutRecordContext::Replicate + }; self.start_put_record(r, Quorum::All, context) } else { break; @@ -3179,16 +3181,20 @@ impl QueryInfo { key: key.clone(), query_id, }, - QueryInfo::PutRecord { record, phase, .. } => match phase { - PutRecordPhase::GetClosestPeers => HandlerIn::FindNodeReq { - key: record.key.to_vec(), - query_id, - }, - PutRecordPhase::PutRecord { .. } => HandlerIn::PutRecord { - record: record.clone(), - query_id, - }, - }, + QueryInfo::PutRecord { record, phase, .. } => { + match phase { + PutRecordPhase::GetClosestPeers => HandlerIn::FindNodeReq { + key: record.key.to_vec(), + query_id, + }, + PutRecordPhase::PutRecord { .. } => { + HandlerIn::PutRecord { + record: record.clone(), + query_id, + } + } + } + } } } } diff --git a/protocols/kad/src/behaviour/test.rs b/protocols/kad/src/behaviour/test.rs index 522eebcba92..70ca19e5312 100644 --- a/protocols/kad/src/behaviour/test.rs +++ b/protocols/kad/src/behaviour/test.rs @@ -58,11 +58,12 @@ fn build_node() -> (Multiaddr, TestSwarm) { fn build_node_with_config(cfg: Config) -> (Multiaddr, TestSwarm) { let local_key = identity::Keypair::generate_ed25519(); let local_public_key = local_key.public(); - let transport = MemoryTransport::default() - .upgrade(upgrade::Version::V1) - .authenticate(noise::Config::new(&local_key).unwrap()) - .multiplex(yamux::Config::default()) - .boxed(); + let transport = + MemoryTransport::default() + .upgrade(upgrade::Version::V1) + .authenticate(noise::Config::new(&local_key).unwrap()) + .multiplex(yamux::Config::default()) + .boxed(); let local_id = local_public_key.to_peer_id(); let store = MemoryStore::new(local_id); @@ -1243,15 +1244,16 @@ fn manual_bucket_inserts() { // 1 -> 2 -> [3 -> ...] let mut swarms = build_connected_nodes_with_config(3, 1, cfg); // The peers and their addresses for which we expect `RoutablePeer` events. - let mut expected = swarms - .iter() - .skip(2) - .map(|(a, s)| { - let pid = *Swarm::local_peer_id(s); - let addr = a.clone().with(Protocol::P2p(pid)); - (addr, pid) - }) - .collect::>(); + let mut expected = + swarms + .iter() + .skip(2) + .map(|(a, s)| { + let pid = *Swarm::local_peer_id(s); + let addr = a.clone().with(Protocol::P2p(pid)); + (addr, pid) + }) + .collect::>(); // We collect the peers for which a `RoutablePeer` event // was received in here to check at the end of the test // that none of them was inserted into a bucket. @@ -1265,10 +1267,9 @@ fn manual_bucket_inserts() { for (_, swarm) in swarms.iter_mut() { loop { match swarm.poll_next_unpin(ctx) { - Poll::Ready(Some(SwarmEvent::Behaviour(Event::RoutablePeer { - peer, - address, - }))) => { + Poll::Ready( + Some(SwarmEvent::Behaviour(Event::RoutablePeer { peer, address })) + ) => { assert_eq!(peer, expected.remove(&address).expect("Missing address")); routable.push(peer); if expected.is_empty() { @@ -1405,10 +1406,9 @@ fn get_providers_single() { .. }) if id == query_id => { if index.last { - assert!(matches!( - ok, - GetProvidersOk::FinishedWithNoAdditionalRecord { .. } - )); + assert!( + matches!(ok, GetProvidersOk::FinishedWithNoAdditionalRecord { .. }) + ); break; } else { assert!(matches!(ok, GetProvidersOk::FoundProviders { .. })); diff --git a/protocols/kad/src/handler.rs b/protocols/kad/src/handler.rs index adfb076541c..5eb533df9cc 100644 --- a/protocols/kad/src/handler.rs +++ b/protocols/kad/src/handler.rs @@ -916,9 +916,9 @@ impl futures::Stream for OutboundSubstreamState { *this = OutboundSubstreamState::Closing(substream); let event = process_kad_response(msg, query_id); - return Poll::Ready(Some(ConnectionHandlerEvent::NotifyBehaviour( - event, - ))); + return Poll::Ready( + Some(ConnectionHandlerEvent::NotifyBehaviour(event)) + ); } Poll::Pending => { *this = OutboundSubstreamState::WaitingAnswer(substream, query_id); @@ -931,9 +931,9 @@ impl futures::Stream for OutboundSubstreamState { query_id, }; - return Poll::Ready(Some(ConnectionHandlerEvent::NotifyBehaviour( - event, - ))); + return Poll::Ready( + Some(ConnectionHandlerEvent::NotifyBehaviour(event)) + ); } Poll::Ready(None) => { *this = OutboundSubstreamState::Done; @@ -942,9 +942,9 @@ impl futures::Stream for OutboundSubstreamState { query_id, }; - return Poll::Ready(Some(ConnectionHandlerEvent::NotifyBehaviour( - event, - ))); + return Poll::Ready( + Some(ConnectionHandlerEvent::NotifyBehaviour(event)) + ); } } } @@ -1140,11 +1140,13 @@ fn process_kad_response(event: KadResponseMsg, query_id: QueryId) -> HandlerEven KadResponseMsg::GetProviders { closer_peers, provider_peers, - } => HandlerEvent::GetProvidersRes { - closer_peers, - provider_peers, - query_id, - }, + } => { + HandlerEvent::GetProvidersRes { + closer_peers, + provider_peers, + query_id, + } + } KadResponseMsg::GetValue { record, closer_peers, diff --git a/protocols/kad/src/protocol.rs b/protocols/kad/src/protocol.rs index 7fe2d1130b1..5435254ef73 100644 --- a/protocols/kad/src/protocol.rs +++ b/protocols/kad/src/protocol.rs @@ -371,12 +371,14 @@ fn req_msg_to_proto(kad_msg: KadRequestMsg) -> proto::Message { providerPeers: vec![provider.into()], ..proto::Message::default() }, - KadRequestMsg::GetValue { key } => proto::Message { - type_pb: proto::MessageType::GET_VALUE, - clusterLevelRaw: 10, - key: key.to_vec(), - ..proto::Message::default() - }, + KadRequestMsg::GetValue { key } => { + proto::Message { + type_pb: proto::MessageType::GET_VALUE, + clusterLevelRaw: 10, + key: key.to_vec(), + ..proto::Message::default() + } + } KadRequestMsg::PutValue { record } => proto::Message { type_pb: proto::MessageType::PUT_VALUE, key: record.key.to_vec(), @@ -552,11 +554,12 @@ fn record_from_proto(record: proto::Record) -> Result { None }; - let expires = if record.ttl > 0 { - Some(Instant::now() + Duration::from_secs(record.ttl as u64)) - } else { - None - }; + let expires = + if record.ttl > 0 { + Some(Instant::now() + Duration::from_secs(record.ttl as u64)) + } else { + None + }; Ok(Record { key, @@ -627,11 +630,12 @@ mod tests { multiaddr.with_p2p(other_peer_id).unwrap() }; - let invalid_multiaddr = { - let a = vec![255; 8]; - assert!(Multiaddr::try_from(a.clone()).is_err()); - a - }; + let invalid_multiaddr = + { + let a = vec![255; 8]; + assert!(Multiaddr::try_from(a.clone()).is_err()); + a + }; let payload = proto::Peer { id: peer_id.to_bytes(), diff --git a/protocols/kad/src/query.rs b/protocols/kad/src/query.rs index bb240d5864a..8321e2c8da5 100644 --- a/protocols/kad/src/query.rs +++ b/protocols/kad/src/query.rs @@ -134,16 +134,15 @@ impl QueryPool { T: Into + Clone, I: IntoIterator>, { - let cfg = ClosestPeersIterConfig { - num_results: self.config.replication_factor, - parallelism: self.config.parallelism, - ..ClosestPeersIterConfig::default() - }; + let cfg = + ClosestPeersIterConfig { + num_results: self.config.replication_factor, + parallelism: self.config.parallelism, + ..ClosestPeersIterConfig::default() + }; let peer_iter = if self.config.disjoint_query_paths { - QueryPeerIter::ClosestDisjoint(ClosestDisjointPeersIter::with_config( - cfg, target, peers, - )) + QueryPeerIter::ClosestDisjoint(ClosestDisjointPeersIter::with_config(cfg, target, peers)) } else { QueryPeerIter::Closest(ClosestPeersIter::with_config(cfg, target, peers)) }; diff --git a/protocols/kad/src/query/peers/closest.rs b/protocols/kad/src/query/peers/closest.rs index 01155b7f010..835619134cf 100644 --- a/protocols/kad/src/query/peers/closest.rs +++ b/protocols/kad/src/query/peers/closest.rs @@ -718,14 +718,14 @@ mod tests { fn timeout() { fn prop(mut iter: ClosestPeersIter) -> bool { let mut now = Instant::now(); - let peer = iter - .closest_peers - .values() - .next() - .unwrap() - .key - .clone() - .into_preimage(); + let peer = + iter.closest_peers + .values() + .next() + .unwrap() + .key + .clone() + .into_preimage(); // Poll the iterator for the first peer to be in progress. match iter.next(now) { diff --git a/protocols/kad/src/query/peers/closest/disjoint.rs b/protocols/kad/src/query/peers/closest/disjoint.rs index 68721f93d7c..33f8cecb2d6 100644 --- a/protocols/kad/src/query/peers/closest/disjoint.rs +++ b/protocols/kad/src/query/peers/closest/disjoint.rs @@ -249,9 +249,9 @@ impl ClosestDisjointPeersIter { // The iterator is the first to contact this peer. self.contacted_peers .insert(peer.clone().into_owned(), PeerState::new(i)); - return PeersIterState::Waiting(Some(Cow::Owned( - peer.into_owned(), - ))); + return PeersIterState::Waiting( + Some(Cow::Owned(peer.into_owned())), + ); } } } diff --git a/protocols/kad/src/query/peers/fixed.rs b/protocols/kad/src/query/peers/fixed.rs index 50a969380a3..0dff9bac827 100644 --- a/protocols/kad/src/query/peers/fixed.rs +++ b/protocols/kad/src/query/peers/fixed.rs @@ -174,10 +174,11 @@ mod test { #[test] fn decrease_num_waiting_on_failure() { - let mut iter = FixedPeersIter::new( - vec![PeerId::random(), PeerId::random()], - NonZeroUsize::new(1).unwrap(), - ); + let mut iter = + FixedPeersIter::new( + vec![PeerId::random(), PeerId::random()], + NonZeroUsize::new(1).unwrap(), + ); match iter.next() { PeersIterState::Waiting(Some(peer)) => { diff --git a/protocols/perf/src/bin/perf.rs b/protocols/perf/src/bin/perf.rs index 9ac8f0a6cde..405c12559e3 100644 --- a/protocols/perf/src/bin/perf.rs +++ b/protocols/perf/src/bin/perf.rs @@ -230,13 +230,14 @@ async fn connect( let start = Instant::now(); swarm.dial(server_address.clone()).unwrap(); - let server_peer_id = match swarm.next().await.unwrap() { - SwarmEvent::ConnectionEstablished { peer_id, .. } => peer_id, - SwarmEvent::OutgoingConnectionError { peer_id, error, .. } => { - bail!("Outgoing connection error to {:?}: {:?}", peer_id, error); - } - e => panic!("{e:?}"), - }; + let server_peer_id = + match swarm.next().await.unwrap() { + SwarmEvent::ConnectionEstablished { peer_id, .. } => peer_id, + SwarmEvent::OutgoingConnectionError { peer_id, error, .. } => { + bail!("Outgoing connection error to {:?}: {:?}", peer_id, error); + } + e => panic!("{e:?}"), + }; let duration = start.elapsed(); let duration_seconds = duration.as_secs_f64(); diff --git a/protocols/perf/src/client/handler.rs b/protocols/perf/src/client/handler.rs index 2a2c5499fc2..b22bd6edca4 100644 --- a/protocols/perf/src/client/handler.rs +++ b/protocols/perf/src/client/handler.rs @@ -115,10 +115,9 @@ impl ConnectionHandler for Handler { ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { protocol, .. }) => void::unreachable(protocol), - ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound { - protocol, - info: (), - }) => { + ConnectionEvent::FullyNegotiatedOutbound( + FullyNegotiatedOutbound { protocol, info: () } + ) => { let Command { id, params } = self .requested_streams .pop_front() diff --git a/protocols/perf/src/protocol.rs b/protocols/perf/src/protocol.rs index d2d65b42303..75d20f13c76 100644 --- a/protocols/perf/src/protocol.rs +++ b/protocols/perf/src/protocol.rs @@ -156,12 +156,13 @@ async fn send_receive_inner( pub(crate) async fn receive_send( mut stream: S, ) -> Result { - let to_send = { - let mut buf = [0; 8]; - stream.read_exact(&mut buf).await?; + let to_send = + { + let mut buf = [0; 8]; + stream.read_exact(&mut buf).await?; - u64::from_be_bytes(buf) as usize - }; + u64::from_be_bytes(buf) as usize + }; let read_start = Instant::now(); diff --git a/protocols/perf/src/server/handler.rs b/protocols/perf/src/server/handler.rs index ddfe8f881e5..d776fd8c42a 100644 --- a/protocols/perf/src/server/handler.rs +++ b/protocols/perf/src/server/handler.rs @@ -86,10 +86,9 @@ impl ConnectionHandler for Handler { >, ) { match event { - ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { - protocol, - info: _, - }) => { + ConnectionEvent::FullyNegotiatedInbound( + FullyNegotiatedInbound { protocol, info: _ } + ) => { if self .inbound .try_push(crate::protocol::receive_send(protocol).boxed()) diff --git a/protocols/ping/src/handler.rs b/protocols/ping/src/handler.rs index 5e6fc2cd2cf..49b5b219cb0 100644 --- a/protocols/ping/src/handler.rs +++ b/protocols/ping/src/handler.rs @@ -232,9 +232,9 @@ impl ConnectionHandler for Handler { } State::Inactive { reported: false } => { self.state = State::Inactive { reported: true }; - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Err( - Failure::Unsupported, - ))); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Err(Failure::Unsupported)) + ); } State::Active => {} } @@ -298,9 +298,9 @@ impl ConnectionHandler for Handler { break; } Poll::Ready(()) => { - self.outbound = Some(OutboundState::Ping( - send_ping(stream, self.config.timeout).boxed(), - )); + self.outbound = Some( + OutboundState::Ping(send_ping(stream, self.config.timeout).boxed()) + ); } }, Some(OutboundState::OpenStream) => { @@ -312,9 +312,9 @@ impl ConnectionHandler for Handler { Poll::Ready(()) => { self.outbound = Some(OutboundState::OpenStream); let protocol = SubstreamProtocol::new(ReadyUpgrade::new(PROTOCOL_NAME), ()); - return Poll::Ready(ConnectionHandlerEvent::OutboundSubstreamRequest { - protocol, - }); + return Poll::Ready( + ConnectionHandlerEvent::OutboundSubstreamRequest { protocol } + ); } }, } @@ -345,9 +345,8 @@ impl ConnectionHandler for Handler { .. }) => { stream.ignore_for_keep_alive(); - self.outbound = Some(OutboundState::Ping( - send_ping(stream, self.config.timeout).boxed(), - )); + self.outbound = + Some(OutboundState::Ping(send_ping(stream, self.config.timeout).boxed())); } ConnectionEvent::DialUpgradeError(dial_upgrade_error) => { self.on_dial_upgrade_error(dial_upgrade_error) diff --git a/protocols/ping/src/protocol.rs b/protocols/ping/src/protocol.rs index 28549e1c198..4b395b098a8 100644 --- a/protocols/ping/src/protocol.rs +++ b/protocols/ping/src/protocol.rs @@ -62,10 +62,7 @@ where if recv_payload == payload { Ok((stream, started.elapsed())) } else { - Err(io::Error::new( - io::ErrorKind::InvalidData, - "Ping payload mismatch", - )) + Err(io::Error::new(io::ErrorKind::InvalidData, "Ping payload mismatch")) } } diff --git a/protocols/relay/src/behaviour.rs b/protocols/relay/src/behaviour.rs index 59f679c9890..0c3c67d4870 100644 --- a/protocols/relay/src/behaviour.rs +++ b/protocols/relay/src/behaviour.rs @@ -62,34 +62,30 @@ pub struct Config { impl Config { pub fn reservation_rate_per_peer(mut self, limit: NonZeroU32, interval: Duration) -> Self { - self.reservation_rate_limiters - .push(rate_limiter::new_per_peer( - rate_limiter::GenericRateLimiterConfig { limit, interval }, - )); + self.reservation_rate_limiters.push( + rate_limiter::new_per_peer(rate_limiter::GenericRateLimiterConfig { limit, interval }) + ); self } pub fn circuit_src_per_peer(mut self, limit: NonZeroU32, interval: Duration) -> Self { - self.circuit_src_rate_limiters - .push(rate_limiter::new_per_peer( - rate_limiter::GenericRateLimiterConfig { limit, interval }, - )); + self.circuit_src_rate_limiters.push( + rate_limiter::new_per_peer(rate_limiter::GenericRateLimiterConfig { limit, interval }) + ); self } pub fn reservation_rate_per_ip(mut self, limit: NonZeroU32, interval: Duration) -> Self { - self.reservation_rate_limiters - .push(rate_limiter::new_per_ip( - rate_limiter::GenericRateLimiterConfig { limit, interval }, - )); + self.reservation_rate_limiters.push( + rate_limiter::new_per_ip(rate_limiter::GenericRateLimiterConfig { limit, interval }) + ); self } pub fn circuit_src_per_ip(mut self, limit: NonZeroU32, interval: Duration) -> Self { - self.circuit_src_rate_limiters - .push(rate_limiter::new_per_ip( - rate_limiter::GenericRateLimiterConfig { limit, interval }, - )); + self.circuit_src_rate_limiters.push( + rate_limiter::new_per_ip(rate_limiter::GenericRateLimiterConfig { limit, interval }) + ); self } } diff --git a/protocols/relay/src/behaviour/handler.rs b/protocols/relay/src/behaviour/handler.rs index 958c6a9b906..4fd31aa90b0 100644 --- a/protocols/relay/src/behaviour/handler.rs +++ b/protocols/relay/src/behaviour/handler.rs @@ -804,9 +804,9 @@ impl ConnectionHandler for Handler { .map(|fut| fut.poll_unpin(cx)) { self.active_reservation = None; - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::ReservationTimedOut {}, - )); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::ReservationTimedOut {}) + ); } // Progress reservation request. diff --git a/protocols/relay/src/behaviour/rate_limiter.rs b/protocols/relay/src/behaviour/rate_limiter.rs index a4a127e1253..7dc57a95bb2 100644 --- a/protocols/relay/src/behaviour/rate_limiter.rs +++ b/protocols/relay/src/behaviour/rate_limiter.rs @@ -103,13 +103,15 @@ impl GenericRateLimiter { match self.buckets.get_mut(&id) { // If the bucket exists, try to take a token. - Some(balance) => match balance.checked_sub(1) { - Some(a) => { - *balance = a; - true + Some(balance) => { + match balance.checked_sub(1) { + Some(a) => { + *balance = a; + true + } + None => false, } - None => false, - }, + } // If the bucket is missing, act like the bucket has `limit` number of tokens. Take one // token and track the new bucket balance. None => { diff --git a/protocols/relay/src/copy_future.rs b/protocols/relay/src/copy_future.rs index 755344cd698..1fa78115c9d 100644 --- a/protocols/relay/src/copy_future.rs +++ b/protocols/relay/src/copy_future.rs @@ -74,10 +74,9 @@ where loop { if this.bytes_sent > this.max_circuit_bytes { - return Poll::Ready(Err(io::Error::new( - io::ErrorKind::Other, - "Max circuit bytes reached.", - ))); + return Poll::Ready(Err( + io::Error::new(io::ErrorKind::Other, "Max circuit bytes reached.") + )); } enum Status { diff --git a/protocols/relay/src/priv_client.rs b/protocols/relay/src/priv_client.rs index e414852ef81..5235dd01262 100644 --- a/protocols/relay/src/priv_client.rs +++ b/protocols/relay/src/priv_client.rs @@ -279,105 +279,108 @@ impl NetworkBehaviour for Behaviour { return Poll::Ready(action); } - let action = match ready!(self.from_transport.poll_next_unpin(cx)) { - Some(transport::TransportToBehaviourMsg::ListenReq { - relay_peer_id, - relay_addr, - to_listener, - }) => { - match self - .directly_connected_peers - .get(&relay_peer_id) - .and_then(|cs| cs.first()) - { - Some(connection_id) => { - self.reservation_addresses.insert( - *connection_id, - ( - relay_addr - .with(Protocol::P2p(relay_peer_id)) - .with(Protocol::P2pCircuit) - .with(Protocol::P2p(self.local_peer_id)), - ReservationStatus::Pending, - ), - ); - - ToSwarm::NotifyHandler { - peer_id: relay_peer_id, - handler: NotifyHandler::One(*connection_id), - event: Either::Left(handler::In::Reserve { to_listener }), + let action = + match ready!(self.from_transport.poll_next_unpin(cx)) { + Some(transport::TransportToBehaviourMsg::ListenReq { + relay_peer_id, + relay_addr, + to_listener, + }) => { + match self + .directly_connected_peers + .get(&relay_peer_id) + .and_then(|cs| cs.first()) + { + Some(connection_id) => { + self.reservation_addresses.insert( + *connection_id, + ( + relay_addr + .with(Protocol::P2p(relay_peer_id)) + .with(Protocol::P2pCircuit) + .with(Protocol::P2p(self.local_peer_id)), + ReservationStatus::Pending, + ), + ); + + ToSwarm::NotifyHandler { + peer_id: relay_peer_id, + handler: NotifyHandler::One(*connection_id), + event: Either::Left(handler::In::Reserve { to_listener }), + } + } + None => { + let opts = DialOpts::peer_id(relay_peer_id) + .addresses(vec![relay_addr.clone()]) + .extend_addresses_through_behaviour() + .build(); + let relayed_connection_id = opts.connection_id(); + + self.reservation_addresses.insert( + relayed_connection_id, + ( + relay_addr + .with(Protocol::P2p(relay_peer_id)) + .with(Protocol::P2pCircuit) + .with(Protocol::P2p(self.local_peer_id)), + ReservationStatus::Pending, + ), + ); + + self.pending_handler_commands.insert( + relayed_connection_id, + handler::In::Reserve { to_listener }, + ); + ToSwarm::Dial { opts } } - } - None => { - let opts = DialOpts::peer_id(relay_peer_id) - .addresses(vec![relay_addr.clone()]) - .extend_addresses_through_behaviour() - .build(); - let relayed_connection_id = opts.connection_id(); - - self.reservation_addresses.insert( - relayed_connection_id, - ( - relay_addr - .with(Protocol::P2p(relay_peer_id)) - .with(Protocol::P2pCircuit) - .with(Protocol::P2p(self.local_peer_id)), - ReservationStatus::Pending, - ), - ); - - self.pending_handler_commands - .insert(relayed_connection_id, handler::In::Reserve { to_listener }); - ToSwarm::Dial { opts } } } - } - Some(transport::TransportToBehaviourMsg::DialReq { - relay_addr, - relay_peer_id, - dst_peer_id, - send_back, - .. - }) => { - match self - .directly_connected_peers - .get(&relay_peer_id) - .and_then(|cs| cs.first()) - { - Some(connection_id) => ToSwarm::NotifyHandler { - peer_id: relay_peer_id, - handler: NotifyHandler::One(*connection_id), - event: Either::Left(handler::In::EstablishCircuit { - to_dial: send_back, - dst_peer_id, - }), - }, - None => { - let opts = DialOpts::peer_id(relay_peer_id) - .addresses(vec![relay_addr]) - .extend_addresses_through_behaviour() - .build(); - let connection_id = opts.connection_id(); - - self.pending_handler_commands.insert( - connection_id, - handler::In::EstablishCircuit { + Some(transport::TransportToBehaviourMsg::DialReq { + relay_addr, + relay_peer_id, + dst_peer_id, + send_back, + .. + }) => { + match self + .directly_connected_peers + .get(&relay_peer_id) + .and_then(|cs| cs.first()) + { + Some(connection_id) => ToSwarm::NotifyHandler { + peer_id: relay_peer_id, + handler: NotifyHandler::One(*connection_id), + event: Either::Left(handler::In::EstablishCircuit { to_dial: send_back, dst_peer_id, - }, - ); - - ToSwarm::Dial { opts } + }), + }, + None => { + let opts = DialOpts::peer_id(relay_peer_id) + .addresses(vec![relay_addr]) + .extend_addresses_through_behaviour() + .build(); + let connection_id = opts.connection_id(); + + self.pending_handler_commands.insert( + connection_id, + handler::In::EstablishCircuit { + to_dial: send_back, + dst_peer_id, + }, + ); + + ToSwarm::Dial { opts } + } } } - } - None => unreachable!( - "`relay::Behaviour` polled after channel from \ + None => unreachable!( + "`relay::Behaviour` polled after channel from \ `Transport` has been closed. Unreachable under \ the assumption that the `client::Behaviour` is never polled after \ `client::Transport` is dropped.", - ), - }; + ), + }; Poll::Ready(action) } diff --git a/protocols/relay/src/priv_client/handler.rs b/protocols/relay/src/priv_client/handler.rs index 1925d6f6ab4..a34b78e7609 100644 --- a/protocols/relay/src/priv_client/handler.rs +++ b/protocols/relay/src/priv_client/handler.rs @@ -96,13 +96,14 @@ pub struct Handler { remote_addr: Multiaddr, /// Queue of events to return when polled. - queued_events: VecDeque< - ConnectionHandlerEvent< - ::OutboundProtocol, - ::OutboundOpenInfo, - ::ToBehaviour, + queued_events: + VecDeque< + ConnectionHandlerEvent< + ::OutboundProtocol, + ::OutboundOpenInfo, + ::ToBehaviour, + >, >, - >, /// We issue a stream upgrade for each pending request. pending_requests: VecDeque, @@ -301,11 +302,9 @@ impl ConnectionHandler for Handler { continue; } Poll::Ready((Err(futures_bounded::Timeout { .. }), mut to_listener)) => { - if let Err(e) = - to_listener.try_send(transport::ToListenerMsg::Reservation(Err( - outbound_hop::ReserveError::Io(io::ErrorKind::TimedOut.into()), - ))) - { + if let Err(e) = to_listener.try_send(transport::ToListenerMsg::Reservation( + Err(outbound_hop::ReserveError::Io(io::ErrorKind::TimedOut.into())), + )) { tracing::debug!("Unable to send error to listener: {}", e.into_send_error()) } self.reservation.failed(); @@ -346,9 +345,7 @@ impl ConnectionHandler for Handler { } Poll::Ready((Err(futures_bounded::Timeout { .. }), to_dialer)) => { if to_dialer - .send(Err(outbound_hop::ConnectError::Io( - io::ErrorKind::TimedOut.into(), - ))) + .send(Err(outbound_hop::ConnectError::Io(io::ErrorKind::TimedOut.into()))) .is_err() { tracing::debug!("Unable to send error to dialer") @@ -535,11 +532,12 @@ impl Reservation { }, ))); - *self = Reservation::Accepted { - renewal_timeout, - pending_msgs, - to_listener, - }; + *self = + Reservation::Accepted { + renewal_timeout, + pending_msgs, + to_listener, + }; Event::ReservationReqAccepted { renewal, limit } } diff --git a/protocols/relay/src/protocol/outbound_hop.rs b/protocols/relay/src/protocol/outbound_hop.rs index e5f9a6a0a52..c4ed8065773 100644 --- a/protocols/relay/src/protocol/outbound_hop.rs +++ b/protocols/relay/src/protocol/outbound_hop.rs @@ -139,14 +139,10 @@ pub(crate) async fn make_reservation(stream: Stream) -> Result { - return Err(ReserveError::Protocol( - ProtocolViolation::UnexpectedTypeConnect, - )); + return Err(ReserveError::Protocol(ProtocolViolation::UnexpectedTypeConnect)); } proto::HopMessageType::RESERVE => { - return Err(ReserveError::Protocol( - ProtocolViolation::UnexpectedTypeReserve, - )); + return Err(ReserveError::Protocol(ProtocolViolation::UnexpectedTypeReserve)); } proto::HopMessageType::STATUS => {} } @@ -161,21 +157,14 @@ pub(crate) async fn make_reservation(stream: Stream) -> Result { return Err(ReserveError::ResourceLimitExceeded); } - s => { - return Err(ReserveError::Protocol(ProtocolViolation::UnexpectedStatus( - s, - ))) - } + s => return Err(ReserveError::Protocol(ProtocolViolation::UnexpectedStatus(s))), } - let reservation = reservation.ok_or(ReserveError::Protocol( - ProtocolViolation::MissingReservationField, - ))?; + let reservation = + reservation.ok_or(ReserveError::Protocol(ProtocolViolation::MissingReservationField))?; if reservation.addrs.is_empty() { - return Err(ReserveError::Protocol( - ProtocolViolation::NoAddressesInReservation, - )); + return Err(ReserveError::Protocol(ProtocolViolation::NoAddressesInReservation)); } let addrs = reservation @@ -197,9 +186,7 @@ pub(crate) async fn make_reservation(stream: Stream) -> Result { - return Err(ConnectError::Protocol( - ProtocolViolation::UnexpectedTypeConnect, - )); + return Err(ConnectError::Protocol(ProtocolViolation::UnexpectedTypeConnect)); } proto::HopMessageType::RESERVE => { - return Err(ConnectError::Protocol( - ProtocolViolation::UnexpectedTypeReserve, - )); + return Err(ConnectError::Protocol(ProtocolViolation::UnexpectedTypeReserve)); } proto::HopMessageType::STATUS => {} } @@ -267,14 +250,10 @@ pub(crate) async fn open_circuit( return Err(ConnectError::PermissionDenied); } Some(s) => { - return Err(ConnectError::Protocol(ProtocolViolation::UnexpectedStatus( - s, - ))); + return Err(ConnectError::Protocol(ProtocolViolation::UnexpectedStatus(s))); } None => { - return Err(ConnectError::Protocol( - ProtocolViolation::MissingStatusField, - )); + return Err(ConnectError::Protocol(ProtocolViolation::MissingStatusField)); } } diff --git a/protocols/relay/tests/lib.rs b/protocols/relay/tests/lib.rs index 2b28d5a50cd..d3e058a00d7 100644 --- a/protocols/relay/tests/lib.rs +++ b/protocols/relay/tests/lib.rs @@ -241,9 +241,9 @@ async fn connection_established_to( SwarmEvent::Behaviour(ClientEvent::Ping(ping::Event { peer, .. })) if peer == other => { break } - SwarmEvent::Behaviour(ClientEvent::Relay( - relay::client::Event::OutboundCircuitEstablished { .. }, - )) => {} + SwarmEvent::Behaviour( + ClientEvent::Relay(relay::client::Event::OutboundCircuitEstablished { .. }) + ) => {} SwarmEvent::Behaviour(ClientEvent::Relay( relay::client::Event::InboundCircuitEstablished { src_peer_id, .. }, )) => { @@ -317,14 +317,15 @@ fn propagate_reservation_error_to_listener() { // Wait for connection to relay. assert!(pool.run_until(wait_for_dial(&mut client, relay_peer_id))); - let error = pool.run_until(client.wait(|e| match e { - SwarmEvent::ListenerClosed { - listener_id, - reason: Err(e), - .. - } if listener_id == reservation_listener => Some(e), - _ => None, - })); + let error = + pool.run_until(client.wait(|e| match e { + SwarmEvent::ListenerClosed { + listener_id, + reason: Err(e), + .. + } if listener_id == reservation_listener => Some(e), + _ => None, + })); let error = error .source() @@ -366,17 +367,18 @@ fn propagate_connect_error_to_unknown_peer_to_dialer() { src.dial(opts).unwrap(); - let (failed_address, error) = pool.run_until(src.wait(|e| match e { - SwarmEvent::OutgoingConnectionError { - connection_id, - error: DialError::Transport(mut errors), - .. - } if connection_id == circuit_connection_id => { - assert_eq!(errors.len(), 1); - Some(errors.remove(0)) - } - _ => None, - })); + let (failed_address, error) = + pool.run_until(src.wait(|e| match e { + SwarmEvent::OutgoingConnectionError { + connection_id, + error: DialError::Transport(mut errors), + .. + } if connection_id == circuit_connection_id => { + assert_eq!(errors.len(), 1); + Some(errors.remove(0)) + } + _ => None, + })); // This is a bit wonky but we need to get the _actual_ source error :) let error = error @@ -388,10 +390,7 @@ fn propagate_connect_error_to_unknown_peer_to_dialer() { .unwrap(); assert_eq!(failed_address, dst_addr); - assert!(matches!( - error, - relay::outbound::hop::ConnectError::NoReservation - )); + assert!(matches!(error, relay::outbound::hop::ConnectError::NoReservation)); } #[test] @@ -466,10 +465,11 @@ fn build_client_with_config(config: Config) -> Swarm { let local_peer_id = local_key.public().to_peer_id(); let (relay_transport, behaviour) = relay::client::new(local_peer_id); - let transport = upgrade_transport( - OrTransport::new(relay_transport, MemoryTransport::default()).boxed(), - &local_key, - ); + let transport = + upgrade_transport( + OrTransport::new(relay_transport, MemoryTransport::default()).boxed(), + &local_key, + ); Swarm::new( transport, diff --git a/protocols/rendezvous/src/codec.rs b/protocols/rendezvous/src/codec.rs index 41432a91d8c..ff72d67c30d 100644 --- a/protocols/rendezvous/src/codec.rs +++ b/protocols/rendezvous/src/codec.rs @@ -144,14 +144,15 @@ impl Cookie { } let namespace = bytes.split_off(8); - let namespace = if namespace.is_empty() { - None - } else { - Some( - Namespace::new(String::from_utf8(namespace).map_err(|_| InvalidCookie)?) - .map_err(|_| InvalidCookie)?, - ) - }; + let namespace = + if namespace.is_empty() { + None + } else { + Some( + Namespace::new(String::from_utf8(namespace).map_err(|_| InvalidCookie)?) + .map_err(|_| InvalidCookie)?, + ) + }; let bytes = <[u8; 8]>::try_from(bytes).map_err(|_| InvalidCookie)?; let id = u64::from_be_bytes(bytes); @@ -450,9 +451,9 @@ impl TryFrom for Message { .transpose()? .ok_or(ConversionError::MissingNamespace)?, ttl, - record: PeerRecord::from_signed_envelope(SignedEnvelope::from_protobuf_encoding( - &signed_peer_record, - )?)?, + record: PeerRecord::from_signed_envelope( + SignedEnvelope::from_protobuf_encoding(&signed_peer_record)? + )?, }), proto::Message { type_pb: Some(proto::MessageType::REGISTER_RESPONSE), diff --git a/protocols/rendezvous/src/server.rs b/protocols/rendezvous/src/server.rs index 78aa42043cd..e0c52c3041b 100644 --- a/protocols/rendezvous/src/server.rs +++ b/protocols/rendezvous/src/server.rs @@ -161,9 +161,7 @@ impl NetworkBehaviour for Behaviour { cx: &mut Context<'_>, ) -> Poll>> { if let Poll::Ready(ExpiredRegistration(registration)) = self.registrations.poll(cx) { - return Poll::Ready(ToSwarm::GenerateEvent(Event::RegistrationExpired( - registration, - ))); + return Poll::Ready(ToSwarm::GenerateEvent(Event::RegistrationExpired(registration))); } loop { @@ -203,16 +201,14 @@ impl NetworkBehaviour for Behaviour { continue; } - ToSwarm::GenerateEvent(libp2p_request_response::Event::ResponseSent { - .. - }) + ToSwarm::GenerateEvent(libp2p_request_response::Event::ResponseSent { .. }) | ToSwarm::GenerateEvent(libp2p_request_response::Event::Message { peer: _, message: libp2p_request_response::Message::Response { .. }, }) - | ToSwarm::GenerateEvent(libp2p_request_response::Event::OutboundFailure { - .. - }) => { + | ToSwarm::GenerateEvent( + libp2p_request_response::Event::OutboundFailure { .. } + ) => { continue; } ToSwarm::Dial { .. } @@ -459,10 +455,11 @@ impl Registrations { _ => {} } - let mut reggos_of_last_discover = cookie - .and_then(|cookie| self.cookies.get(&cookie)) - .cloned() - .unwrap_or_default(); + let mut reggos_of_last_discover = + cookie + .and_then(|cookie| self.cookies.get(&cookie)) + .cloned() + .unwrap_or_default(); let ids = self .registrations_for_peer diff --git a/protocols/rendezvous/tests/rendezvous.rs b/protocols/rendezvous/tests/rendezvous.rs index c2de88fd615..cc5727ad9bc 100644 --- a/protocols/rendezvous/tests/rendezvous.rs +++ b/protocols/rendezvous/tests/rendezvous.rs @@ -288,23 +288,26 @@ async fn discover_allows_for_dial_by_peer_id() { bob.dial(alices_peer_id).unwrap(); - let alice_connected_to = tokio::spawn(async move { - loop { - if let SwarmEvent::ConnectionEstablished { peer_id, .. } = - alice.select_next_some().await - { - break peer_id; + let alice_connected_to = + tokio::spawn(async move { + loop { + if let SwarmEvent::ConnectionEstablished { peer_id, .. } = + alice.select_next_some().await + { + break peer_id; + } } - } - }); - let bob_connected_to = tokio::spawn(async move { - loop { - if let SwarmEvent::ConnectionEstablished { peer_id, .. } = bob.select_next_some().await - { - break peer_id; + }); + let bob_connected_to = + tokio::spawn(async move { + loop { + if let SwarmEvent::ConnectionEstablished { peer_id, .. } = + bob.select_next_some().await + { + break peer_id; + } } - } - }); + }); assert_eq!(alice_connected_to.await.unwrap(), bobs_peer_id); assert_eq!(bob_connected_to.await.unwrap(), alices_peer_id); diff --git a/protocols/request-response/src/handler.rs b/protocols/request-response/src/handler.rs index 2d45e0d7dc3..aa85aefd0d2 100644 --- a/protocols/request-response/src/handler.rs +++ b/protocols/request-response/src/handler.rs @@ -64,17 +64,19 @@ where requested_outbound: VecDeque>, /// A channel for receiving inbound requests. - inbound_receiver: mpsc::Receiver<( - InboundRequestId, - TCodec::Request, - oneshot::Sender, - )>, + inbound_receiver: + mpsc::Receiver<( + InboundRequestId, + TCodec::Request, + oneshot::Sender, + )>, /// The [`mpsc::Sender`] for the above receiver. Cloned for each inbound request. - inbound_sender: mpsc::Sender<( - InboundRequestId, - TCodec::Request, - oneshot::Sender, - )>, + inbound_sender: + mpsc::Sender<( + InboundRequestId, + TCodec::Request, + oneshot::Sender, + )>, inbound_request_id: Arc, @@ -411,14 +413,14 @@ where )); } Poll::Ready((RequestId::Inbound(id), Err(futures_bounded::Timeout { .. }))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::InboundTimeout(id), - )); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::InboundTimeout(id)) + ); } Poll::Ready((RequestId::Outbound(id), Err(futures_bounded::Timeout { .. }))) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - Event::OutboundTimeout(id), - )); + return Poll::Ready( + ConnectionHandlerEvent::NotifyBehaviour(Event::OutboundTimeout(id)) + ); } Poll::Pending => {} } diff --git a/protocols/request-response/src/lib.rs b/protocols/request-response/src/lib.rs index 824839ebac8..1a2977137a9 100644 --- a/protocols/request-response/src/lib.rs +++ b/protocols/request-response/src/lib.rs @@ -862,10 +862,7 @@ where ); self.pending_events - .push_back(ToSwarm::GenerateEvent(Event::ResponseSent { - peer, - request_id, - })); + .push_back(ToSwarm::GenerateEvent(Event::ResponseSent { peer, request_id })); } handler::Event::ResponseOmission(request_id) => { let removed = self.remove_pending_inbound_response(&peer, connection, request_id); diff --git a/protocols/request-response/tests/error_reporting.rs b/protocols/request-response/tests/error_reporting.rs index 2dc82b2e0c5..96b8bfdbf42 100644 --- a/protocols/request-response/tests/error_reporting.rs +++ b/protocols/request-response/tests/error_reporting.rs @@ -211,31 +211,32 @@ async fn report_inbound_failure_on_write_response() { swarm2.connect(&mut swarm1).await; // Expects OutboundFailure::Io failure with `FailOnWriteResponse` error - let server_task = async move { - let (peer, req_id, action, resp_channel) = wait_request(&mut swarm1).await.unwrap(); - assert_eq!(peer, peer2_id); - assert_eq!(action, Action::FailOnWriteResponse); - swarm1 - .behaviour_mut() - .send_response(resp_channel, Action::FailOnWriteResponse) - .unwrap(); - - let (peer, req_id_done, error) = wait_inbound_failure(&mut swarm1).await.unwrap(); - assert_eq!(peer, peer2_id); - assert_eq!(req_id_done, req_id); - - let error = match error { - InboundFailure::Io(e) => e, - e => panic!("Unexpected error: {e:?}"), + let server_task = + async move { + let (peer, req_id, action, resp_channel) = wait_request(&mut swarm1).await.unwrap(); + assert_eq!(peer, peer2_id); + assert_eq!(action, Action::FailOnWriteResponse); + swarm1 + .behaviour_mut() + .send_response(resp_channel, Action::FailOnWriteResponse) + .unwrap(); + + let (peer, req_id_done, error) = wait_inbound_failure(&mut swarm1).await.unwrap(); + assert_eq!(peer, peer2_id); + assert_eq!(req_id_done, req_id); + + let error = match error { + InboundFailure::Io(e) => e, + e => panic!("Unexpected error: {e:?}"), + }; + + assert_eq!(error.kind(), io::ErrorKind::Other); + assert_eq!( + error.into_inner().unwrap().to_string(), + "FailOnWriteResponse" + ); }; - assert_eq!(error.kind(), io::ErrorKind::Other); - assert_eq!( - error.into_inner().unwrap().to_string(), - "FailOnWriteResponse" - ); - }; - // Expects OutboundFailure::ConnectionClosed or io::ErrorKind::UnexpectedEof let client_task = async move { let req_id = swarm2 diff --git a/protocols/request-response/tests/ping.rs b/protocols/request-response/tests/ping.rs index b9e7878a78b..35ba476da6b 100644 --- a/protocols/request-response/tests/ping.rs +++ b/protocols/request-response/tests/ping.rs @@ -40,15 +40,16 @@ async fn is_response_outbound() { let ping = Ping("ping".to_string().into_bytes()); let offline_peer = PeerId::random(); - let mut swarm1 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new( - [( - StreamProtocol::new("/ping/1"), - request_response::ProtocolSupport::Full, - )], - request_response::Config::default(), - ) - }); + let mut swarm1 = + Swarm::new_ephemeral(|_| { + request_response::cbor::Behaviour::::new( + [( + StreamProtocol::new("/ping/1"), + request_response::ProtocolSupport::Full, + )], + request_response::Config::default(), + ) + }); let request_id1 = swarm1 .behaviour_mut() @@ -91,13 +92,14 @@ async fn ping_protocol() { let protocols = iter::once((StreamProtocol::new("/ping/1"), ProtocolSupport::Full)); let cfg = request_response::Config::default(); - let mut swarm1 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) - }); + let mut swarm1 = + Swarm::new_ephemeral(|_| { + request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) + }); let peer1_id = *swarm1.local_peer_id(); - let mut swarm2 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols, cfg) - }); + let mut swarm2 = Swarm::new_ephemeral( + |_| request_response::cbor::Behaviour::::new(protocols, cfg) + ); let peer2_id = *swarm2.local_peer_id(); swarm1.listen().with_memory_addr_external().await; @@ -184,13 +186,14 @@ async fn emits_inbound_connection_closed_failure() { let protocols = iter::once((StreamProtocol::new("/ping/1"), ProtocolSupport::Full)); let cfg = request_response::Config::default(); - let mut swarm1 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) - }); + let mut swarm1 = + Swarm::new_ephemeral(|_| { + request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) + }); let peer1_id = *swarm1.local_peer_id(); - let mut swarm2 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols, cfg) - }); + let mut swarm2 = Swarm::new_ephemeral( + |_| request_response::cbor::Behaviour::::new(protocols, cfg) + ); let peer2_id = *swarm2.local_peer_id(); swarm1.listen().with_memory_addr_external().await; @@ -249,13 +252,14 @@ async fn emits_inbound_connection_closed_if_channel_is_dropped() { let protocols = iter::once((StreamProtocol::new("/ping/1"), ProtocolSupport::Full)); let cfg = request_response::Config::default(); - let mut swarm1 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) - }); + let mut swarm1 = + Swarm::new_ephemeral(|_| { + request_response::cbor::Behaviour::::new(protocols.clone(), cfg.clone()) + }); let peer1_id = *swarm1.local_peer_id(); - let mut swarm2 = Swarm::new_ephemeral(|_| { - request_response::cbor::Behaviour::::new(protocols, cfg) - }); + let mut swarm2 = Swarm::new_ephemeral( + |_| request_response::cbor::Behaviour::::new(protocols, cfg) + ); let peer2_id = *swarm2.local_peer_id(); swarm1.listen().with_memory_addr_external().await; @@ -264,27 +268,28 @@ async fn emits_inbound_connection_closed_if_channel_is_dropped() { swarm2.behaviour_mut().send_request(&peer1_id, ping.clone()); // Wait for swarm 1 to receive request by swarm 2. - let event = loop { - futures::select!( - event = swarm1.select_next_some() => { - if let SwarmEvent::Behaviour(request_response::Event::Message { - peer, - message: request_response::Message::Request { request, channel, .. } - }) = event { - assert_eq!(&request, &ping); - assert_eq!(&peer, &peer2_id); - - drop(channel); - continue; - } - }, - event = swarm2.select_next_some() => { - if let SwarmEvent::Behaviour(ev) = event { - break ev; - } - }, - ) - }; + let event = + loop { + futures::select!( + event = swarm1.select_next_some() => { + if let SwarmEvent::Behaviour(request_response::Event::Message { + peer, + message: request_response::Message::Request { request, channel, .. } + }) = event { + assert_eq!(&request, &ping); + assert_eq!(&peer, &peer2_id); + + drop(channel); + continue; + } + }, + event = swarm2.select_next_some() => { + if let SwarmEvent::Behaviour(ev) = event { + break ev; + } + }, + ) + }; let error = match event { request_response::Event::OutboundFailure { error, .. } => error, diff --git a/protocols/upnp/src/behaviour.rs b/protocols/upnp/src/behaviour.rs index a94ef9526dd..45ec469dd4e 100644 --- a/protocols/upnp/src/behaviour.rs +++ b/protocols/upnp/src/behaviour.rs @@ -258,13 +258,14 @@ 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 (addr, protocol) = + match multiaddr_to_socketaddr_protocol(multiaddr.clone()) { + Ok(addr_port) => addr_port, + Err(()) => { + tracing::debug!("multiaddress not supported for UPnP {multiaddr}"); + return; + } + }; if let Some((mapping, _state)) = self .mappings @@ -409,9 +410,9 @@ impl NetworkBehaviour for Behaviour { if let Poll::Ready(Some(result)) = gateway.receiver.poll_next_unpin(cx) { match result { GatewayEvent::Mapped(mapping) => { - let new_state = MappingState::Active(Delay::new( - Duration::from_secs(MAPPING_TIMEOUT), - )); + let new_state = MappingState::Active( + Delay::new(Duration::from_secs(MAPPING_TIMEOUT)) + ); match self .mappings diff --git a/protocols/upnp/src/tokio.rs b/protocols/upnp/src/tokio.rs index c6a40182b33..497f59a1cad 100644 --- a/protocols/upnp/src/tokio.rs +++ b/protocols/upnp/src/tokio.rs @@ -107,15 +107,16 @@ pub(crate) fn search_gateway() -> oneshot::Receiver addr, - Err(err) => { - search_result_sender - .send(Err(err.into())) - .expect("receiver shouldn't have been dropped"); - return; - } - }; + let external_addr = + match gateway.get_external_ip().await { + Ok(addr) => addr, + Err(err) => { + search_result_sender + .send(Err(err.into())) + .expect("receiver shouldn't have been dropped"); + return; + } + }; search_result_sender .send(Ok(Gateway { diff --git a/swarm-derive/src/lib.rs b/swarm-derive/src/lib.rs index 514975390b0..fcac5785468 100644 --- a/swarm-derive/src/lib.rs +++ b/swarm-derive/src/lib.rs @@ -42,14 +42,12 @@ pub fn hello_macro_derive(input: TokenStream) -> TokenStream { fn build(ast: &DeriveInput) -> syn::Result { match ast.data { Data::Struct(ref s) => build_struct(ast, s), - Data::Enum(_) => Err(syn::Error::new_spanned( - ast, - "Cannot derive `NetworkBehaviour` on enums", - )), - Data::Union(_) => Err(syn::Error::new_spanned( - ast, - "Cannot derive `NetworkBehaviour` on union", - )), + Data::Enum(_) => { + Err(syn::Error::new_spanned(ast, "Cannot derive `NetworkBehaviour` on enums")) + } + Data::Union(_) => { + Err(syn::Error::new_spanned(ast, "Cannot derive `NetworkBehaviour` on union")) + } } } @@ -199,27 +197,28 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result>(); + let where_clause = + { + let additional = data_struct + .fields + .iter() + .map(|field| { + let ty = &field.ty; + quote! {#ty: #trait_to_impl} + }) + .chain(out_event_from_clauses) + .collect::>(); - if let Some(where_clause) = where_clause { - if where_clause.predicates.trailing_punct() { - Some(quote! {#where_clause #(#additional),* }) + if let Some(where_clause) = where_clause { + if where_clause.predicates.trailing_punct() { + Some(quote! {#where_clause #(#additional),* }) + } else { + Some(quote! {#where_clause, #(#additional),*}) + } } else { - Some(quote! {#where_clause, #(#additional),*}) + Some(quote! {where #(#additional),*}) } - } else { - Some(quote! {where #(#additional),*}) - } - }; + }; // Build the list of statements to put in the body of `on_swarm_event()` // for the `FromSwarm::ConnectionEstablished` variant. @@ -252,35 +251,37 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result quote! { - self.#i.on_swarm_event(#from_swarm::AddressChange(#address_change { - peer_id, - connection_id, - old, - new, - })); - }, - None => quote! { - self.#field_n.on_swarm_event(#from_swarm::AddressChange(#address_change { - peer_id, - connection_id, - old, - new, - })); - }, - }) - }; + let on_address_change_stmts = + { + data_struct + .fields + .iter() + .enumerate() + .map(|(field_n, field)| match field.ident { + Some(ref i) => quote! { + self.#i.on_swarm_event(#from_swarm::AddressChange(#address_change { + peer_id, + connection_id, + old, + new, + })); + }, + None => quote! { + self.#field_n.on_swarm_event(#from_swarm::AddressChange(#address_change { + peer_id, + connection_id, + old, + new, + })); + }, + }) + }; // Build the list of statements to put in the body of `on_swarm_event()` // for the `FromSwarm::ConnectionClosed` variant. - let on_connection_closed_stmts = { - data_struct + let on_connection_closed_stmts = + { + data_struct .fields .iter() .rev() @@ -309,7 +310,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result syn::Result quote! { - self.#i.on_swarm_event(#from_swarm::ListenFailure(#listen_failure { - local_addr, - send_back_addr, - connection_id, - error - })); - }, - None => quote! { - self.#enum_n.on_swarm_event(#from_swarm::ListenFailure(#listen_failure { - local_addr, - send_back_addr, - connection_id, - error - })); - }, - }); - - // Build the list of statements to put in the body of `on_swarm_event()` - // for the `FromSwarm::NewListener` variant. - let on_new_listener_stmts = { + let on_listen_failure_stmts = data_struct .fields .iter() .enumerate() - .map(|(field_n, field)| match field.ident { + .map(|(enum_n, field)| match field.ident { Some(ref i) => quote! { - self.#i.on_swarm_event(#from_swarm::NewListener(#new_listener { - listener_id, + self.#i.on_swarm_event(#from_swarm::ListenFailure(#listen_failure { + local_addr, + send_back_addr, + connection_id, + error })); }, None => quote! { - self.#field_n.on_swarm_event(#from_swarm::NewListener(#new_listener { - listener_id, + self.#enum_n.on_swarm_event(#from_swarm::ListenFailure(#listen_failure { + local_addr, + send_back_addr, + connection_id, + error })); }, - }) - }; + }); // Build the list of statements to put in the body of `on_swarm_event()` - // for the `FromSwarm::NewListenAddr` variant. - let on_new_listen_addr_stmts = { + // for the `FromSwarm::NewListener` variant. + let on_new_listener_stmts = { data_struct .fields .iter() .enumerate() .map(|(field_n, field)| match field.ident { Some(ref i) => quote! { - self.#i.on_swarm_event(#from_swarm::NewListenAddr(#new_listen_addr { + self.#i.on_swarm_event(#from_swarm::NewListener(#new_listener { listener_id, - addr, })); }, None => quote! { - self.#field_n.on_swarm_event(#from_swarm::NewListenAddr(#new_listen_addr { + self.#field_n.on_swarm_event(#from_swarm::NewListener(#new_listener { listener_id, - addr, })); }, }) }; + // Build the list of statements to put in the body of `on_swarm_event()` + // for the `FromSwarm::NewListenAddr` variant. + let on_new_listen_addr_stmts = + { + data_struct + .fields + .iter() + .enumerate() + .map(|(field_n, field)| match field.ident { + Some(ref i) => quote! { + self.#i.on_swarm_event(#from_swarm::NewListenAddr(#new_listen_addr { + listener_id, + addr, + })); + }, + None => quote! { + self.#field_n.on_swarm_event(#from_swarm::NewListenAddr(#new_listen_addr { + listener_id, + addr, + })); + }, + }) + }; + // Build the list of statements to put in the body of `on_swarm_event()` // for the `FromSwarm::ExpiredListenAddr` variant. let on_expired_listen_addr_stmts = { @@ -491,26 +494,27 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result quote! { - self.#i.on_swarm_event(#from_swarm::ListenerError(#listener_error { - listener_id, - err, - })); - }, - None => quote! { - self.#field_n.on_swarm_event(#from_swarm::ListenerError(#listener_error { - listener_id, - err, - })); - }, - }) - }; + let on_listener_error_stmts = + { + data_struct + .fields + .iter() + .enumerate() + .map(|(field_n, field)| match field.ident { + Some(ref i) => quote! { + self.#i.on_swarm_event(#from_swarm::ListenerError(#listener_error { + listener_id, + err, + })); + }, + None => quote! { + self.#field_n.on_swarm_event(#from_swarm::ListenerError(#listener_error { + listener_id, + err, + })); + }, + }) + }; // Build the list of statements to put in the body of `on_swarm_event()` // for the `FromSwarm::ListenerClosed` variant. diff --git a/swarm-test/src/lib.rs b/swarm-test/src/lib.rs index 48f5bcbf4ef..592974bd4ea 100644 --- a/swarm-test/src/lib.rs +++ b/swarm-test/src/lib.rs @@ -398,17 +398,18 @@ where .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()) .unwrap(); - let tcp_multiaddr = swarm - .wait(|e| match e { - SwarmEvent::NewListenAddr { - address, - listener_id, - } => (listener_id == tcp_addr_listener_id).then_some(address), - other => { - panic!("Unexpected event while waiting for `NewListenAddr`: {other:?}") - } - }) - .await; + let tcp_multiaddr = + swarm + .wait(|e| match e { + SwarmEvent::NewListenAddr { + address, + listener_id, + } => (listener_id == tcp_addr_listener_id).then_some(address), + other => { + panic!("Unexpected event while waiting for `NewListenAddr`: {other:?}") + } + }) + .await; if self.add_memory_external { swarm.add_external_address(memory_multiaddr.clone()); diff --git a/swarm/src/behaviour.rs b/swarm/src/behaviour.rs index c25b14e75e3..0dee8489f5c 100644 --- a/swarm/src/behaviour.rs +++ b/swarm/src/behaviour.rs @@ -320,11 +320,13 @@ impl ToSwarm { peer_id, handler, event, - } => ToSwarm::NotifyHandler { - peer_id, - handler, - event: f(event), - }, + } => { + ToSwarm::NotifyHandler { + peer_id, + handler, + event: f(event), + } + } ToSwarm::CloseConnection { peer_id, connection, diff --git a/swarm/src/behaviour/either.rs b/swarm/src/behaviour/either.rs index 25da83fa11f..88142deedb6 100644 --- a/swarm/src/behaviour/either.rs +++ b/swarm/src/behaviour/either.rs @@ -55,18 +55,22 @@ where remote_addr: &Multiaddr, ) -> Result, ConnectionDenied> { let handler = match self { - Either::Left(inner) => Either::Left(inner.handle_established_inbound_connection( - connection_id, - peer, - local_addr, - remote_addr, - )?), - Either::Right(inner) => Either::Right(inner.handle_established_inbound_connection( - connection_id, - peer, - local_addr, - remote_addr, - )?), + Either::Left(inner) => { + Either::Left(inner.handle_established_inbound_connection( + connection_id, + peer, + local_addr, + remote_addr, + )?) + } + Either::Right(inner) => { + Either::Right(inner.handle_established_inbound_connection( + connection_id, + peer, + local_addr, + remote_addr, + )?) + } }; Ok(handler) @@ -105,18 +109,22 @@ where role_override: Endpoint, ) -> Result, ConnectionDenied> { let handler = match self { - Either::Left(inner) => Either::Left(inner.handle_established_outbound_connection( - connection_id, - peer, - addr, - role_override, - )?), - Either::Right(inner) => Either::Right(inner.handle_established_outbound_connection( - connection_id, - peer, - addr, - role_override, - )?), + Either::Left(inner) => { + Either::Left(inner.handle_established_outbound_connection( + connection_id, + peer, + addr, + role_override, + )?) + } + Either::Right(inner) => { + Either::Right(inner.handle_established_outbound_connection( + connection_id, + peer, + addr, + role_override, + )?) + } }; Ok(handler) diff --git a/swarm/src/behaviour/toggle.rs b/swarm/src/behaviour/toggle.rs index e81c5343701..8f1662fa66b 100644 --- a/swarm/src/behaviour/toggle.rs +++ b/swarm/src/behaviour/toggle.rs @@ -232,29 +232,30 @@ where ::InboundProtocol, >, ) { - let (inner, info) = match (self.inner.as_mut(), info) { - (Some(inner), Either::Left(info)) => (inner, info), - // Ignore listen upgrade errors in disabled state. - (None, Either::Right(())) => return, - (Some(_), Either::Right(())) => panic!( - "Unexpected `Either::Right` inbound info through \ + let (inner, info) = + match (self.inner.as_mut(), info) { + (Some(inner), Either::Left(info)) => (inner, info), + // Ignore listen upgrade errors in disabled state. + (None, Either::Right(())) => return, + (Some(_), Either::Right(())) => panic!( + "Unexpected `Either::Right` inbound info through \ `on_listen_upgrade_error` in enabled state.", - ), - (None, Either::Left(_)) => panic!( - "Unexpected `Either::Left` inbound info through \ + ), + (None, Either::Left(_)) => panic!( + "Unexpected `Either::Left` inbound info through \ `on_listen_upgrade_error` in disabled state.", - ), - }; + ), + }; let err = match err { Either::Left(e) => e, Either::Right(v) => void::unreachable(v), }; - inner.on_connection_event(ConnectionEvent::ListenUpgradeError(ListenUpgradeError { - info, - error: err, - })); + inner + .on_connection_event( + ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info, error: err }) + ); } } @@ -323,16 +324,17 @@ where ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound { protocol: out, info, - }) => self - .inner - .as_mut() - .expect("Can't receive an outbound substream if disabled; QED") - .on_connection_event(ConnectionEvent::FullyNegotiatedOutbound( - FullyNegotiatedOutbound { - protocol: out, - info, - }, - )), + }) => { + self.inner + .as_mut() + .expect("Can't receive an outbound substream if disabled; QED") + .on_connection_event(ConnectionEvent::FullyNegotiatedOutbound( + FullyNegotiatedOutbound { + protocol: out, + info, + }, + )) + } ConnectionEvent::AddressChange(address_change) => { if let Some(inner) = self.inner.as_mut() { inner.on_connection_event(ConnectionEvent::AddressChange(AddressChange { @@ -344,10 +346,9 @@ where .inner .as_mut() .expect("Can't receive an outbound substream if disabled; QED") - .on_connection_event(ConnectionEvent::DialUpgradeError(DialUpgradeError { - info, - error: err, - })), + .on_connection_event( + ConnectionEvent::DialUpgradeError(DialUpgradeError { info, error: err }) + ), ConnectionEvent::ListenUpgradeError(listen_upgrade_error) => { self.on_listen_upgrade_error(listen_upgrade_error) } diff --git a/swarm/src/connection.rs b/swarm/src/connection.rs index 15c49bb7bd5..e897092fd7c 100644 --- a/swarm/src/connection.rs +++ b/swarm/src/connection.rs @@ -117,13 +117,14 @@ where /// The underlying handler. handler: THandler, /// Futures that upgrade incoming substreams. - negotiating_in: FuturesUnordered< - StreamUpgrade< - THandler::InboundOpenInfo, - ::Output, - ::Error, + negotiating_in: + FuturesUnordered< + StreamUpgrade< + THandler::InboundOpenInfo, + ::Output, + ::Error, + >, >, - >, /// Futures that upgrade outgoing substreams. negotiating_out: FuturesUnordered< StreamUpgrade< @@ -320,9 +321,9 @@ where continue; } Poll::Ready(Some((info, Err(error)))) => { - handler.on_connection_event(ConnectionEvent::DialUpgradeError( - DialUpgradeError { info, error }, - )); + handler.on_connection_event( + ConnectionEvent::DialUpgradeError(DialUpgradeError { info, error }) + ); continue; } } @@ -338,9 +339,9 @@ where continue; } Poll::Ready(Some((info, Err(StreamUpgradeError::Apply(error))))) => { - handler.on_connection_event(ConnectionEvent::ListenUpgradeError( - ListenUpgradeError { info, error }, - )); + handler.on_connection_event( + ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info, error }) + ); continue; } Poll::Ready(Some((_, Err(StreamUpgradeError::Io(e))))) => { @@ -420,11 +421,9 @@ where Poll::Ready(substream) => { let protocol = handler.listen_protocol(); - negotiating_in.push(StreamUpgrade::new_inbound( - substream, - protocol, - stream_counter.clone(), - )); + negotiating_in.push( + StreamUpgrade::new_inbound(substream, protocol, stream_counter.clone()) + ); continue; // Go back to the top, handler can potentially make progress again. } @@ -475,10 +474,7 @@ fn compute_new_shutdown( let now = Instant::now(); let safe_keep_alive = checked_add_fraction(now, idle_timeout); - Some(Shutdown::Later( - Delay::new(safe_keep_alive), - now + safe_keep_alive, - )) + Some(Shutdown::Later(Delay::new(safe_keep_alive), now + safe_keep_alive)) } (_, true) => Some(Shutdown::None), } @@ -903,13 +899,14 @@ mod tests { async fn idle_timeout_with_keep_alive_no() { let idle_timeout = Duration::from_millis(100); - let mut connection = Connection::new( - StreamMuxerBox::new(PendingStreamMuxer), - dummy::ConnectionHandler, - None, - 0, - idle_timeout, - ); + let mut connection = + Connection::new( + StreamMuxerBox::new(PendingStreamMuxer), + dummy::ConnectionHandler, + None, + 0, + idle_timeout, + ); assert!(connection.poll_noop_waker().is_pending()); @@ -1163,14 +1160,12 @@ mod tests { >, ) { match event { - ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { - protocol, - .. - }) => void::unreachable(protocol), - ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound { - protocol, - .. - }) => void::unreachable(protocol), + ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { protocol, .. }) => { + void::unreachable(protocol) + } + ConnectionEvent::FullyNegotiatedOutbound( + FullyNegotiatedOutbound { protocol, .. } + ) => void::unreachable(protocol), ConnectionEvent::DialUpgradeError(DialUpgradeError { error, .. }) => { self.error = Some(error) } diff --git a/swarm/src/connection/pool/task.rs b/swarm/src/connection/pool/task.rs index 08674fd2ee5..ab1c35e02b3 100644 --- a/swarm/src/connection/pool/task.rs +++ b/swarm/src/connection/pool/task.rs @@ -107,21 +107,23 @@ pub(crate) async fn new_for_pending_outgoing_connection( } Either::Left((Ok(v), _)) => void::unreachable(v), Either::Right((Ok((address, output, errors)), _)) => { - let _ = events - .send(PendingConnectionEvent::ConnectionEstablished { - id: connection_id, - output, - outgoing: Some((address, errors)), - }) - .await; + let _ = + events + .send(PendingConnectionEvent::ConnectionEstablished { + id: connection_id, + output, + outgoing: Some((address, errors)), + }) + .await; } Either::Right((Err(e), _)) => { - let _ = events - .send(PendingConnectionEvent::PendingFailed { - id: connection_id, - error: Either::Left(PendingOutboundConnectionError::Transport(e)), - }) - .await; + let _ = + events + .send(PendingConnectionEvent::PendingFailed { + id: connection_id, + error: Either::Left(PendingOutboundConnectionError::Transport(e)), + }) + .await; } } } @@ -154,14 +156,15 @@ pub(crate) async fn new_for_pending_incoming_connection( .await; } Either::Right((Err(e), _)) => { - let _ = events - .send(PendingConnectionEvent::PendingFailed { - id: connection_id, - error: Either::Right(PendingInboundConnectionError::Transport( - TransportError::Other(e), - )), - }) - .await; + let _ = + events + .send(PendingConnectionEvent::PendingFailed { + id: connection_id, + error: Either::Right( + PendingInboundConnectionError::Transport(TransportError::Other(e)) + ), + }) + .await; } } } @@ -200,13 +203,14 @@ pub(crate) async fn new_for_established_connection( let error = closing_muxer.await.err().map(ConnectionError::IO); - let _ = events - .send(EstablishedConnectionEvent::Closed { - id: connection_id, - peer_id, - error, - }) - .await; + let _ = + events + .send(EstablishedConnectionEvent::Closed { + id: connection_id, + peer_id, + error, + }) + .await; return; } }, diff --git a/swarm/src/handler/either.rs b/swarm/src/handler/either.rs index a5aab9b5fee..ab7cfb28a86 100644 --- a/swarm/src/handler/either.rs +++ b/swarm/src/handler/either.rs @@ -156,26 +156,26 @@ where ConnectionEvent::FullyNegotiatedInbound(fully_negotiated_inbound) => { match (fully_negotiated_inbound.transpose(), self) { (Either::Left(fully_negotiated_inbound), Either::Left(handler)) => handler - .on_connection_event(ConnectionEvent::FullyNegotiatedInbound( - fully_negotiated_inbound, - )), + .on_connection_event( + ConnectionEvent::FullyNegotiatedInbound(fully_negotiated_inbound) + ), (Either::Right(fully_negotiated_inbound), Either::Right(handler)) => handler - .on_connection_event(ConnectionEvent::FullyNegotiatedInbound( - fully_negotiated_inbound, - )), + .on_connection_event( + ConnectionEvent::FullyNegotiatedInbound(fully_negotiated_inbound) + ), _ => unreachable!(), } } ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) => { match (fully_negotiated_outbound.transpose(), self) { (Either::Left(fully_negotiated_outbound), Either::Left(handler)) => handler - .on_connection_event(ConnectionEvent::FullyNegotiatedOutbound( - fully_negotiated_outbound, - )), + .on_connection_event( + ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) + ), (Either::Right(fully_negotiated_outbound), Either::Right(handler)) => handler - .on_connection_event(ConnectionEvent::FullyNegotiatedOutbound( - fully_negotiated_outbound, - )), + .on_connection_event( + ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) + ), _ => unreachable!(), } } @@ -191,13 +191,13 @@ where ConnectionEvent::ListenUpgradeError(listen_upgrade_error) => { match (listen_upgrade_error.transpose(), self) { (Either::Left(listen_upgrade_error), Either::Left(handler)) => handler - .on_connection_event(ConnectionEvent::ListenUpgradeError( - listen_upgrade_error, - )), + .on_connection_event( + ConnectionEvent::ListenUpgradeError(listen_upgrade_error) + ), (Either::Right(listen_upgrade_error), Either::Right(handler)) => handler - .on_connection_event(ConnectionEvent::ListenUpgradeError( - listen_upgrade_error, - )), + .on_connection_event( + ConnectionEvent::ListenUpgradeError(listen_upgrade_error) + ), _ => unreachable!(), } } @@ -210,21 +210,27 @@ where } }, ConnectionEvent::LocalProtocolsChange(supported_protocols) => match self { - Either::Left(handler) => handler.on_connection_event( - ConnectionEvent::LocalProtocolsChange(supported_protocols), - ), - Either::Right(handler) => handler.on_connection_event( - ConnectionEvent::LocalProtocolsChange(supported_protocols), - ), - }, - ConnectionEvent::RemoteProtocolsChange(supported_protocols) => match self { - Either::Left(handler) => handler.on_connection_event( - ConnectionEvent::RemoteProtocolsChange(supported_protocols), - ), - Either::Right(handler) => handler.on_connection_event( - ConnectionEvent::RemoteProtocolsChange(supported_protocols), - ), + Either::Left(handler) => { + handler.on_connection_event( + ConnectionEvent::LocalProtocolsChange(supported_protocols) + ) + } + Either::Right(handler) => { + handler.on_connection_event( + ConnectionEvent::LocalProtocolsChange(supported_protocols) + ) + } }, + ConnectionEvent::RemoteProtocolsChange(supported_protocols) => { + match self { + Either::Left(handler) => handler.on_connection_event( + ConnectionEvent::RemoteProtocolsChange(supported_protocols), + ), + Either::Right(handler) => handler.on_connection_event( + ConnectionEvent::RemoteProtocolsChange(supported_protocols), + ), + } + } } } } diff --git a/swarm/src/handler/multi.rs b/swarm/src/handler/multi.rs index 0b4549ed733..03f0d575dc9 100644 --- a/swarm/src/handler/multi.rs +++ b/swarm/src/handler/multi.rs @@ -93,10 +93,9 @@ where ) { if let Some(h) = self.handlers.get_mut(&key) { if let Some(i) = info.take(&key) { - h.on_connection_event(ConnectionEvent::ListenUpgradeError(ListenUpgradeError { - info: i, - error, - })); + h.on_connection_event( + ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info: i, error }) + ); } } } @@ -182,9 +181,9 @@ where } ConnectionEvent::AddressChange(AddressChange { new_address }) => { for h in self.handlers.values_mut() { - h.on_connection_event(ConnectionEvent::AddressChange(AddressChange { - new_address, - })); + h.on_connection_event( + ConnectionEvent::AddressChange(AddressChange { new_address }) + ); } } ConnectionEvent::DialUpgradeError(DialUpgradeError { @@ -192,10 +191,9 @@ where error, }) => { if let Some(h) = self.handlers.get_mut(&key) { - h.on_connection_event(ConnectionEvent::DialUpgradeError(DialUpgradeError { - info: arg, - error, - })); + h.on_connection_event( + ConnectionEvent::DialUpgradeError(DialUpgradeError { info: arg, error }) + ); } else { tracing::error!("DialUpgradeError: no handler for protocol") } @@ -205,16 +203,16 @@ where } ConnectionEvent::LocalProtocolsChange(supported_protocols) => { for h in self.handlers.values_mut() { - h.on_connection_event(ConnectionEvent::LocalProtocolsChange( - supported_protocols.clone(), - )); + h.on_connection_event( + ConnectionEvent::LocalProtocolsChange(supported_protocols.clone()) + ); } } ConnectionEvent::RemoteProtocolsChange(supported_protocols) => { for h in self.handlers.values_mut() { - h.on_connection_event(ConnectionEvent::RemoteProtocolsChange( - supported_protocols.clone(), - )); + h.on_connection_event( + ConnectionEvent::RemoteProtocolsChange(supported_protocols.clone()) + ); } } } diff --git a/swarm/src/handler/one_shot.rs b/swarm/src/handler/one_shot.rs index b1fc41e9098..4d663196c08 100644 --- a/swarm/src/handler/one_shot.rs +++ b/swarm/src/handler/one_shot.rs @@ -135,9 +135,7 @@ where ConnectionHandlerEvent, > { if !self.events_out.is_empty() { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour( - self.events_out.remove(0), - )); + return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(self.events_out.remove(0))); } else { self.events_out.shrink_to_fit(); } @@ -168,16 +166,14 @@ where >, ) { match event { - ConnectionEvent::FullyNegotiatedInbound(FullyNegotiatedInbound { - protocol: out, - .. - }) => { + ConnectionEvent::FullyNegotiatedInbound( + FullyNegotiatedInbound { protocol: out, .. } + ) => { self.events_out.push(Ok(out.into())); } - ConnectionEvent::FullyNegotiatedOutbound(FullyNegotiatedOutbound { - protocol: out, - .. - }) => { + ConnectionEvent::FullyNegotiatedOutbound( + FullyNegotiatedOutbound { protocol: out, .. } + ) => { self.dial_negotiated -= 1; self.events_out.push(Ok(out.into())); } @@ -221,10 +217,11 @@ mod tests { #[test] fn do_not_keep_idle_connection_alive() { - let mut handler: OneShotHandler<_, DeniedUpgrade, Void> = OneShotHandler::new( - SubstreamProtocol::new(DeniedUpgrade {}, ()), - Default::default(), - ); + let mut handler: OneShotHandler<_, DeniedUpgrade, Void> = + OneShotHandler::new( + SubstreamProtocol::new(DeniedUpgrade {}, ()), + Default::default(), + ); block_on(poll_fn(|cx| loop { if handler.poll(cx).is_pending() { diff --git a/swarm/src/handler/select.rs b/swarm/src/handler/select.rs index e049252d448..d8949adc9f3 100644 --- a/swarm/src/handler/select.rs +++ b/swarm/src/handler/select.rs @@ -157,18 +157,14 @@ where ) { match error { Either::Left(error) => { - self.proto1 - .on_connection_event(ConnectionEvent::ListenUpgradeError(ListenUpgradeError { - info: i1, - error, - })); + self.proto1.on_connection_event( + ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info: i1, error }) + ); } Either::Right(error) => { - self.proto2 - .on_connection_event(ConnectionEvent::ListenUpgradeError(ListenUpgradeError { - info: i2, - error, - })); + self.proto2.on_connection_event( + ConnectionEvent::ListenUpgradeError(ListenUpgradeError { info: i2, error }) + ); } } } @@ -239,9 +235,7 @@ where match self.proto2.poll(cx) { Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(event)) => { - return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Either::Right( - event, - ))); + return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Either::Right(event))); } Poll::Ready(ConnectionHandlerEvent::OutboundSubstreamRequest { protocol }) => { return Poll::Ready(ConnectionHandlerEvent::OutboundSubstreamRequest { @@ -326,24 +320,21 @@ where self.on_listen_upgrade_error(listen_upgrade_error) } ConnectionEvent::LocalProtocolsChange(supported_protocols) => { - self.proto1 - .on_connection_event(ConnectionEvent::LocalProtocolsChange( - supported_protocols.clone(), - )); + self.proto1.on_connection_event( + ConnectionEvent::LocalProtocolsChange(supported_protocols.clone()) + ); self.proto2 .on_connection_event(ConnectionEvent::LocalProtocolsChange( supported_protocols, )); } ConnectionEvent::RemoteProtocolsChange(supported_protocols) => { - self.proto1 - .on_connection_event(ConnectionEvent::RemoteProtocolsChange( - supported_protocols.clone(), - )); - self.proto2 - .on_connection_event(ConnectionEvent::RemoteProtocolsChange( - supported_protocols, - )); + self.proto1.on_connection_event( + ConnectionEvent::RemoteProtocolsChange(supported_protocols.clone()) + ); + self.proto2.on_connection_event( + ConnectionEvent::RemoteProtocolsChange(supported_protocols) + ); } } } diff --git a/swarm/src/lib.rs b/swarm/src/lib.rs index 0354f39cfdc..0937becc592 100644 --- a/swarm/src/lib.rs +++ b/swarm/src/lib.rs @@ -595,9 +595,7 @@ where } self.behaviour - .on_swarm_event(FromSwarm::NewListener(behaviour::NewListener { - listener_id, - })); + .on_swarm_event(FromSwarm::NewListener(behaviour::NewListener { listener_id })); Ok(()) } @@ -608,9 +606,7 @@ where /// The address is broadcast to all [`NetworkBehaviour`]s via [`FromSwarm::ExternalAddrConfirmed`]. pub fn add_external_address(&mut self, a: Multiaddr) { self.behaviour - .on_swarm_event(FromSwarm::ExternalAddrConfirmed(ExternalAddrConfirmed { - addr: &a, - })); + .on_swarm_event(FromSwarm::ExternalAddrConfirmed(ExternalAddrConfirmed { addr: &a })); self.confirmed_external_addr.insert(a); } @@ -1044,9 +1040,9 @@ where ); let addrs = self.listened_addrs.remove(&listener_id).unwrap_or_default(); for addr in addrs.iter() { - self.behaviour.on_swarm_event(FromSwarm::ExpiredListenAddr( - ExpiredListenAddr { listener_id, addr }, - )); + self.behaviour.on_swarm_event( + FromSwarm::ExpiredListenAddr(ExpiredListenAddr { listener_id, addr }) + ); } self.behaviour .on_swarm_event(FromSwarm::ListenerClosed(ListenerClosed { @@ -2133,9 +2129,9 @@ mod tests { {} match swarm2.poll_next_unpin(cx) { - Poll::Ready(Some(SwarmEvent::OutgoingConnectionError { - peer_id, error, .. - })) => Poll::Ready((peer_id, error)), + Poll::Ready(Some(SwarmEvent::OutgoingConnectionError { peer_id, error, .. })) => { + Poll::Ready((peer_id, error)) + } Poll::Ready(x) => panic!("unexpected {x:?}"), Poll::Pending => Poll::Pending, } @@ -2200,9 +2196,7 @@ mod tests { return Poll::Ready(Ok(())); } } - Poll::Ready(Some(SwarmEvent::IncomingConnectionError { - local_addr, .. - })) => { + Poll::Ready(Some(SwarmEvent::IncomingConnectionError { local_addr, .. })) => { assert!(!got_inc_err); assert_eq!(local_addr, local_address); got_inc_err = true; @@ -2323,10 +2317,9 @@ mod tests { // This constitutes a fairly typical error for chained transports. let error = DialError::Transport(vec![( "/ip4/127.0.0.1/tcp/80".parse().unwrap(), - TransportError::Other(io::Error::new( - io::ErrorKind::Other, - MemoryTransportError::Unreachable, - )), + TransportError::Other( + io::Error::new(io::ErrorKind::Other, MemoryTransportError::Unreachable) + ), )]); let string = format!("{error}"); diff --git a/swarm/src/test.rs b/swarm/src/test.rs index 4f6adfc37b0..ba72a8d52c2 100644 --- a/swarm/src/test.rs +++ b/swarm/src/test.rs @@ -303,18 +303,18 @@ where remaining_established, }: ConnectionClosed, ) { - let mut other_closed_connections = self - .on_connection_established - .iter() - .rev() // take last to first - .filter_map(|(peer, .., remaining_established)| { - if &peer_id == peer { - Some(remaining_established) - } else { - None - } - }) - .take(remaining_established); + let mut other_closed_connections = + self.on_connection_established + .iter() + .rev() // take last to first + .filter_map(|(peer, .., remaining_established)| { + if &peer_id == peer { + Some(remaining_established) + } else { + None + } + }) + .take(remaining_established); // We are informed that there are `other_established` additional connections. Ensure that the // number of previous connections is consistent with this @@ -368,11 +368,8 @@ where local_addr: &Multiaddr, remote_addr: &Multiaddr, ) -> Result<(), ConnectionDenied> { - self.handle_pending_inbound_connection.push(( - connection_id, - local_addr.clone(), - remote_addr.clone(), - )); + self.handle_pending_inbound_connection + .push((connection_id, local_addr.clone(), remote_addr.clone())); self.inner .handle_pending_inbound_connection(connection_id, local_addr, remote_addr) } @@ -465,26 +462,20 @@ where FromSwarm::NewListenAddr(NewListenAddr { listener_id, addr }) => { self.on_new_listen_addr.push((listener_id, addr.clone())); self.inner - .on_swarm_event(FromSwarm::NewListenAddr(NewListenAddr { - listener_id, - addr, - })); + .on_swarm_event(FromSwarm::NewListenAddr(NewListenAddr { listener_id, addr })); } FromSwarm::ExpiredListenAddr(ExpiredListenAddr { listener_id, addr }) => { self.on_expired_listen_addr .push((listener_id, addr.clone())); - self.inner - .on_swarm_event(FromSwarm::ExpiredListenAddr(ExpiredListenAddr { - listener_id, - addr, - })); + self.inner.on_swarm_event( + FromSwarm::ExpiredListenAddr(ExpiredListenAddr { listener_id, addr }) + ); } FromSwarm::NewExternalAddrCandidate(NewExternalAddrCandidate { addr }) => { self.on_new_external_addr.push(addr.clone()); - self.inner - .on_swarm_event(FromSwarm::NewExternalAddrCandidate( - NewExternalAddrCandidate { addr }, - )); + self.inner.on_swarm_event( + FromSwarm::NewExternalAddrCandidate(NewExternalAddrCandidate { addr }) + ); } FromSwarm::ExternalAddrExpired(ExternalAddrExpired { addr }) => { self.on_expired_external_addr.push(addr.clone()); diff --git a/swarm/tests/listener.rs b/swarm/tests/listener.rs index 8d22acc90e2..63ba16233b7 100644 --- a/swarm/tests/listener.rs +++ b/swarm/tests/listener.rs @@ -19,18 +19,19 @@ async fn behaviour_listener() { let addr: Multiaddr = Protocol::Memory(0).into(); let id = swarm.behaviour_mut().listen(addr.clone()); - let address = swarm - .wait(|e| match e { - SwarmEvent::NewListenAddr { - listener_id, - address, - } => { - assert_eq!(listener_id, id); - Some(address) - } - _ => None, - }) - .await; + let address = + swarm + .wait(|e| match e { + SwarmEvent::NewListenAddr { + listener_id, + address, + } => { + assert_eq!(listener_id, id); + Some(address) + } + _ => None, + }) + .await; swarm.behaviour_mut().stop_listening(id); diff --git a/transports/dns/src/lib.rs b/transports/dns/src/lib.rs index 0c41990fab1..b32f80ca7be 100644 --- a/transports/dns/src/lib.rs +++ b/transports/dns/src/lib.rs @@ -502,54 +502,58 @@ fn resolve<'a, E: 'a + Send, R: Resolver>( Err(e) => Err(Error::ResolveError(e)), }) .boxed(), - Protocol::Dns4(ref name) => resolver - .ipv4_lookup(name.clone().into_owned()) - .map(move |res| match res { - Ok(ips) => { - let mut ips = ips.into_iter(); - let one = ips - .next() - .expect("If there are no results, `Err(NoRecordsFound)` is expected."); - if let Some(two) = ips.next() { - Ok(Resolved::Many( - iter::once(one) - .chain(iter::once(two)) - .chain(ips) - .map(Ipv4Addr::from) - .map(Protocol::from) - .collect(), - )) - } else { - Ok(Resolved::One(Protocol::from(Ipv4Addr::from(one)))) + Protocol::Dns4(ref name) => { + resolver + .ipv4_lookup(name.clone().into_owned()) + .map(move |res| match res { + Ok(ips) => { + let mut ips = ips.into_iter(); + let one = ips + .next() + .expect("If there are no results, `Err(NoRecordsFound)` is expected."); + if let Some(two) = ips.next() { + Ok(Resolved::Many( + iter::once(one) + .chain(iter::once(two)) + .chain(ips) + .map(Ipv4Addr::from) + .map(Protocol::from) + .collect(), + )) + } else { + Ok(Resolved::One(Protocol::from(Ipv4Addr::from(one)))) + } } - } - Err(e) => Err(Error::ResolveError(e)), - }) - .boxed(), - Protocol::Dns6(ref name) => resolver - .ipv6_lookup(name.clone().into_owned()) - .map(move |res| match res { - Ok(ips) => { - let mut ips = ips.into_iter(); - let one = ips - .next() - .expect("If there are no results, `Err(NoRecordsFound)` is expected."); - if let Some(two) = ips.next() { - Ok(Resolved::Many( - iter::once(one) - .chain(iter::once(two)) - .chain(ips) - .map(Ipv6Addr::from) - .map(Protocol::from) - .collect(), - )) - } else { - Ok(Resolved::One(Protocol::from(Ipv6Addr::from(one)))) + Err(e) => Err(Error::ResolveError(e)), + }) + .boxed() + } + Protocol::Dns6(ref name) => { + resolver + .ipv6_lookup(name.clone().into_owned()) + .map(move |res| match res { + Ok(ips) => { + let mut ips = ips.into_iter(); + let one = ips + .next() + .expect("If there are no results, `Err(NoRecordsFound)` is expected."); + if let Some(two) = ips.next() { + Ok(Resolved::Many( + iter::once(one) + .chain(iter::once(two)) + .chain(ips) + .map(Ipv6Addr::from) + .map(Protocol::from) + .collect(), + )) + } else { + Ok(Resolved::One(Protocol::from(Ipv6Addr::from(one)))) + } } - } - Err(e) => Err(Error::ResolveError(e)), - }) - .boxed(), + Err(e) => Err(Error::ResolveError(e)), + }) + .boxed() + } Protocol::Dnsaddr(ref name) => { let name = [DNSADDR_PREFIX, name].concat(); resolver diff --git a/transports/noise/src/lib.rs b/transports/noise/src/lib.rs index 70fae9d7ee6..89adf589fe0 100644 --- a/transports/noise/src/lib.rs +++ b/transports/noise/src/lib.rs @@ -122,13 +122,14 @@ impl Config { } fn into_responder(self, socket: S) -> Result, Error> { - let session = noise_params_into_builder( - self.params, - &self.prologue, - self.dh_keys.keypair.secret(), - None, - ) - .build_responder()?; + let session = + noise_params_into_builder( + self.params, + &self.prologue, + self.dh_keys.keypair.secret(), + None, + ) + .build_responder()?; let state = State::new( socket, @@ -142,13 +143,14 @@ impl Config { } fn into_initiator(self, socket: S) -> Result, Error> { - let session = noise_params_into_builder( - self.params, - &self.prologue, - self.dh_keys.keypair.secret(), - None, - ) - .build_initiator()?; + let session = + noise_params_into_builder( + self.params, + &self.prologue, + self.dh_keys.keypair.secret(), + None, + ) + .build_initiator()?; let state = State::new( socket, diff --git a/transports/noise/src/protocol.rs b/transports/noise/src/protocol.rs index e37c55c7f10..b9e307a1c79 100644 --- a/transports/noise/src/protocol.rs +++ b/transports/noise/src/protocol.rs @@ -31,11 +31,12 @@ use zeroize::Zeroize; /// Prefix of static key signatures for domain separation. pub(crate) const STATIC_KEY_DOMAIN: &str = "noise-libp2p-static-key:"; -pub(crate) static PARAMS_XX: Lazy = Lazy::new(|| { - "Noise_XX_25519_ChaChaPoly_SHA256" - .parse() - .expect("Invalid protocol name") -}); +pub(crate) static PARAMS_XX: Lazy = + Lazy::new(|| { + "Noise_XX_25519_ChaChaPoly_SHA256" + .parse() + .expect("Invalid protocol name") + }); pub(crate) fn noise_params_into_builder<'b>( params: NoiseParams, diff --git a/transports/plaintext/src/handshake.rs b/transports/plaintext/src/handshake.rs index ddd5f7f8a9b..60679c0bae4 100644 --- a/transports/plaintext/src/handshake.rs +++ b/transports/plaintext/src/handshake.rs @@ -44,28 +44,30 @@ where .map_err(DecodeError)?; tracing::trace!("receiving the remote's exchange"); - let public_key = match framed_socket - .next() - .await - .transpose() - .map_err(DecodeError)? - { - Some(remote) => { - let public_key = PublicKey::try_decode_protobuf(&remote.pubkey.unwrap_or_default())?; - let peer_id = PeerId::from_bytes(&remote.id.unwrap_or_default())?; + let public_key = + match framed_socket + .next() + .await + .transpose() + .map_err(DecodeError)? + { + Some(remote) => { + let public_key = + PublicKey::try_decode_protobuf(&remote.pubkey.unwrap_or_default())?; + let peer_id = PeerId::from_bytes(&remote.id.unwrap_or_default())?; - if peer_id != public_key.to_peer_id() { - return Err(Error::PeerIdMismatch); - } + if peer_id != public_key.to_peer_id() { + return Err(Error::PeerIdMismatch); + } - public_key - } - None => { - tracing::debug!("unexpected eof while waiting for remote's exchange"); - let err = IoError::new(IoErrorKind::BrokenPipe, "unexpected eof"); - return Err(err.into()); - } - }; + public_key + } + None => { + tracing::debug!("unexpected eof while waiting for remote's exchange"); + let err = IoError::new(IoErrorKind::BrokenPipe, "unexpected eof"); + return Err(err.into()); + } + }; tracing::trace!(?public_key, "received exchange from remote"); diff --git a/transports/plaintext/tests/smoke.rs b/transports/plaintext/tests/smoke.rs index f77f23d3ad3..d3ea2c0660c 100644 --- a/transports/plaintext/tests/smoke.rs +++ b/transports/plaintext/tests/smoke.rs @@ -44,12 +44,13 @@ fn variable_msg_length() { let ( (received_client_id, mut server_channel), (received_server_id, mut client_channel), - ) = futures::future::try_join( - plaintext::Config::new(&server_id).upgrade_inbound(server, ""), - plaintext::Config::new(&client_id).upgrade_inbound(client, ""), - ) - .await - .unwrap(); + ) = + futures::future::try_join( + plaintext::Config::new(&server_id).upgrade_inbound(server, ""), + plaintext::Config::new(&client_id).upgrade_inbound(client, ""), + ) + .await + .unwrap(); assert_eq!(received_server_id, server_id.public().to_peer_id()); assert_eq!(received_client_id, client_id.public().to_peer_id()); diff --git a/transports/pnet/tests/smoke.rs b/transports/pnet/tests/smoke.rs index 79ffaeab447..951a43f9cc8 100644 --- a/transports/pnet/tests/smoke.rs +++ b/transports/pnet/tests/smoke.rs @@ -79,17 +79,18 @@ where }; } }; - let await_outbound_connection = async { - loop { - match swarm2.select_next_some().await { - SwarmEvent::ConnectionEstablished { peer_id, .. } => break peer_id, - SwarmEvent::OutgoingConnectionError { error, .. } => { - panic!("Failed to dial: {error}") - } - _ => continue, - }; - } - }; + let await_outbound_connection = + async { + loop { + match swarm2.select_next_some().await { + SwarmEvent::ConnectionEstablished { peer_id, .. } => break peer_id, + SwarmEvent::OutgoingConnectionError { error, .. } => { + panic!("Failed to dial: {error}") + } + _ => continue, + }; + } + }; let (inbound_peer_id, outbound_peer_id) = future::join(await_inbound_connection, await_outbound_connection).await; diff --git a/transports/quic/src/transport.rs b/transports/quic/src/transport.rs index aea3c91093f..027e2653862 100644 --- a/transports/quic/src/transport.rs +++ b/transports/quic/src/transport.rs @@ -312,9 +312,7 @@ impl Transport for GenTransport

{ let socket = self .eligible_listener(&socket_addr) - .ok_or(TransportError::Other( - Error::NoActiveListenerForDialAsListener, - ))? + .ok_or(TransportError::Other(Error::NoActiveListenerForDialAsListener))? .try_clone_socket() .map_err(Self::Error::from)?; @@ -329,9 +327,7 @@ impl Transport for GenTransport

{ // Stale senders, i.e. from failed hole punches are not removed. // Thus, we can just overwrite a stale sender. if !sender_entry.get().is_canceled() { - return Err(TransportError::Other(Error::HolePunchInProgress( - socket_addr, - ))); + return Err(TransportError::Other(Error::HolePunchInProgress(socket_addr))); } sender_entry.insert(sender); } @@ -741,10 +737,11 @@ fn is_quic_addr(addr: &Multiaddr, support_draft_29: bool) -> bool { /// Turns an IP address and port into the corresponding QUIC multiaddr. fn socketaddr_to_multiaddr(socket_addr: &SocketAddr, version: ProtocolVersion) -> Multiaddr { - let quic_proto = match version { - ProtocolVersion::V1 => Protocol::QuicV1, - ProtocolVersion::Draft29 => Protocol::Quic, - }; + let quic_proto = + match version { + ProtocolVersion::V1 => Protocol::QuicV1, + ProtocolVersion::Draft29 => Protocol::Quic, + }; Multiaddr::empty() .with(socket_addr.ip().into()) .with(Protocol::Udp(socket_addr.port())) @@ -824,9 +821,9 @@ mod tests { ), Some(( SocketAddr::new( - IpAddr::V6(Ipv6Addr::new( - 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, - )), + IpAddr::V6( + Ipv6Addr::new(65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535,) + ), 8080, ), ProtocolVersion::V1, @@ -935,10 +932,11 @@ mod tests { let keypair = libp2p_identity::Keypair::generate_ed25519(); let config = Config::new(&keypair); let mut transport = crate::tokio::Transport::new(config); - let port = { - let socket = UdpSocket::bind("127.0.0.1:0").unwrap(); - socket.local_addr().unwrap().port() - }; + let port = + { + let socket = UdpSocket::bind("127.0.0.1:0").unwrap(); + socket.local_addr().unwrap().port() + }; transport .listen_on( diff --git a/transports/quic/tests/smoke.rs b/transports/quic/tests/smoke.rs index 36fb72a5ee7..18c110a0897 100644 --- a/transports/quic/tests/smoke.rs +++ b/transports/quic/tests/smoke.rs @@ -167,25 +167,27 @@ async fn wrapped_with_delay() { // 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 (upgrade, _) = a_transport - .select_next_some() - .await - .into_incoming() - .unwrap(); - let (peer_id, _) = upgrade.await.unwrap(); - - peer_id - }); + let listener = + async_std::task::spawn(async move { + let (upgrade, _) = a_transport + .select_next_some() + .await + .into_incoming() + .unwrap(); + let (peer_id, _) = upgrade.await.unwrap(); + + peer_id + }); // Spawn B // // 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 = b_transport.dial(a_addr).unwrap(); - async { dial.await.unwrap().0 } - }); + let dial = + async_std::task::spawn({ + let dial = b_transport.dial(a_addr).unwrap(); + async { dial.await.unwrap().0 } + }); async_std::task::spawn(async move { b_transport.next().await }); let (a_connected, b_connected) = future::join(listener, dial).await; @@ -226,12 +228,13 @@ fn new_tcp_quic_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox)>) { .authenticate(noise::Config::new(&keypair).unwrap()) .multiplex(yamux::Config::default()); - let transport = OrTransport::new(quic_transport, tcp_transport) - .map(|either_output, _| match either_output { - Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)), - Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)), - }) - .boxed(); + let transport = + OrTransport::new(quic_transport, tcp_transport) + .map(|either_output, _| match either_output { + Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)), + Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)), + }) + .boxed(); (peer_id, transport) } @@ -433,17 +436,18 @@ async fn test_local_listener_reuse() { .unwrap(); // wait until a listener reports a loopback address - let a_listen_addr = 'outer: loop { - let ev = a_transport.next().await.unwrap(); - let listen_addr = ev.into_new_address().unwrap(); - for proto in listen_addr.iter() { - if let Protocol::Ip4(ip4) = proto { - if ip4.is_loopback() { - break 'outer listen_addr; + let a_listen_addr = + 'outer: loop { + let ev = a_transport.next().await.unwrap(); + let listen_addr = ev.into_new_address().unwrap(); + for proto in listen_addr.iter() { + if let Protocol::Ip4(ip4) = proto { + if ip4.is_loopback() { + break 'outer listen_addr; + } } } - } - }; + }; // If we do not poll until the end, `NewAddress` events may be `Ready` and `connect` function // below will panic due to an unexpected event. poll_fn(|cx| { diff --git a/transports/tcp/src/lib.rs b/transports/tcp/src/lib.rs index fbb7008aa5b..957bf3e7d4f 100644 --- a/transports/tcp/src/lib.rs +++ b/transports/tcp/src/lib.rs @@ -891,9 +891,7 @@ mod tests { .unwrap() ), Ok(SocketAddr::new( - IpAddr::V6(Ipv6Addr::new( - 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, - )), + IpAddr::V6(Ipv6Addr::new(65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535,)), 8080, )) ); @@ -1336,10 +1334,11 @@ mod tests { #[cfg(feature = "tokio")] { - let rt = ::tokio::runtime::Builder::new_current_thread() - .enable_io() - .build() - .unwrap(); + let rt = + ::tokio::runtime::Builder::new_current_thread() + .enable_io() + .build() + .unwrap(); assert!(rt.block_on(cycle_listeners::())); } } @@ -1372,10 +1371,11 @@ mod tests { } #[cfg(feature = "tokio")] { - let rt = ::tokio::runtime::Builder::new_current_thread() - .enable_io() - .build() - .unwrap(); + let rt = + ::tokio::runtime::Builder::new_current_thread() + .enable_io() + .build() + .unwrap(); rt.block_on(async { test::(); }); diff --git a/transports/tcp/src/provider/async_io.rs b/transports/tcp/src/provider/async_io.rs index fe0abe42d54..baffe67c229 100644 --- a/transports/tcp/src/provider/async_io.rs +++ b/transports/tcp/src/provider/async_io.rs @@ -96,14 +96,16 @@ impl Provider for Tcp { match l.poll_readable(cx) { Poll::Pending => return Poll::Pending, Poll::Ready(Err(err)) => return Poll::Ready(Err(err)), - Poll::Ready(Ok(())) => match l.accept().now_or_never() { - Some(Err(e)) => return Poll::Ready(Err(e)), - Some(Ok(res)) => break res, - None => { - // Since it doesn't do any harm, account for false positives of - // `poll_readable` just in case, i.e. try again. + Poll::Ready(Ok(())) => { + match l.accept().now_or_never() { + Some(Err(e)) => return Poll::Ready(Err(e)), + Some(Ok(res)) => break res, + None => { + // Since it doesn't do any harm, account for false positives of + // `poll_readable` just in case, i.e. try again. + } } - }, + } } }; diff --git a/transports/tls/src/certificate.rs b/transports/tls/src/certificate.rs index ff9d296bb16..c9e7183c727 100644 --- a/transports/tls/src/certificate.rs +++ b/transports/tls/src/certificate.rs @@ -58,10 +58,9 @@ pub fn generate( let certificate = { let mut params = rcgen::CertificateParams::new(vec![]); params.distinguished_name = rcgen::DistinguishedName::new(); - params.custom_extensions.push(make_libp2p_extension( - identity_keypair, - &certificate_keypair, - )?); + params + .custom_extensions + .push(make_libp2p_extension(identity_keypair, &certificate_keypair)?); params.alg = P2P_SIGNATURE_ALGORITHM; params.key_pair = Some(certificate_keypair); rcgen::Certificate::from_params(params)? @@ -289,10 +288,11 @@ impl P2pCertificate<'_> { _ => return Err(webpki::Error::UnsupportedSignatureAlgorithm), }; let spki = &self.certificate.tbs_certificate.subject_pki; - let key = signature::UnparsedPublicKey::new( - verification_algorithm, - spki.subject_public_key.as_ref(), - ); + let key = + signature::UnparsedPublicKey::new( + verification_algorithm, + spki.subject_public_key.as_ref(), + ); Ok(key) } diff --git a/transports/tls/src/lib.rs b/transports/tls/src/lib.rs index 1edd83e9807..024d73f3622 100644 --- a/transports/tls/src/lib.rs +++ b/transports/tls/src/lib.rs @@ -51,9 +51,9 @@ pub fn make_client_config( .with_safe_default_kx_groups() .with_protocol_versions(verifier::PROTOCOL_VERSIONS) .expect("Cipher suites and kx groups are configured; qed") - .with_custom_certificate_verifier(Arc::new( - verifier::Libp2pCertificateVerifier::with_remote_peer_id(remote_peer_id), - )) + .with_custom_certificate_verifier( + Arc::new(verifier::Libp2pCertificateVerifier::with_remote_peer_id(remote_peer_id)) + ) .with_client_auth_cert(vec![certificate], private_key) .expect("Client cert key DER is valid; qed"); crypto.alpn_protocols = vec![P2P_ALPN.to_vec()]; diff --git a/transports/tls/src/verifier.rs b/transports/tls/src/verifier.rs index 01fdb8fdf11..e78850f5e1e 100644 --- a/transports/tls/src/verifier.rs +++ b/transports/tls/src/verifier.rs @@ -211,9 +211,7 @@ fn verify_presented_certs( intermediates: &[Certificate], ) -> Result { if !intermediates.is_empty() { - return Err(rustls::Error::General( - "libp2p-tls requires exactly one certificate".into(), - )); + return Err(rustls::Error::General("libp2p-tls requires exactly one certificate".into())); } let cert = certificate::parse(end_entity)?; diff --git a/transports/tls/tests/smoke.rs b/transports/tls/tests/smoke.rs index d488ae7846a..6a2cc0b5903 100644 --- a/transports/tls/tests/smoke.rs +++ b/transports/tls/tests/smoke.rs @@ -37,17 +37,18 @@ async fn can_establish_connection() { }; } }; - let await_outbound_connection = async { - loop { - match swarm2.next().await.unwrap() { - SwarmEvent::ConnectionEstablished { peer_id, .. } => break peer_id, - SwarmEvent::OutgoingConnectionError { error, .. } => { - panic!("Failed to dial: {error}") - } - _ => continue, - }; - } - }; + let await_outbound_connection = + async { + loop { + match swarm2.next().await.unwrap() { + SwarmEvent::ConnectionEstablished { peer_id, .. } => break peer_id, + SwarmEvent::OutgoingConnectionError { error, .. } => { + panic!("Failed to dial: {error}") + } + _ => continue, + }; + } + }; let (inbound_peer_id, outbound_peer_id) = future::join(await_inbound_connection, await_outbound_connection).await; diff --git a/transports/uds/src/lib.rs b/transports/uds/src/lib.rs index 075cbadb80a..18c49ede78a 100644 --- a/transports/uds/src/lib.rs +++ b/transports/uds/src/lib.rs @@ -54,13 +54,14 @@ use std::pin::Pin; use std::task::{Context, Poll}; use std::{io, path::PathBuf}; -pub type Listener = BoxStream< - 'static, - Result< - TransportEvent<::ListenerUpgrade, ::Error>, - Result<(), ::Error>, - >, ->; +pub type Listener = + BoxStream< + 'static, + Result< + TransportEvent<::ListenerUpgrade, ::Error>, + Result<(), ::Error>, + >, + >; macro_rules! codegen { ($feature_name:expr, $uds_config:ident, $build_listener:expr, $unix_stream:ty, $($mut_or_not:tt)*) => { @@ -285,9 +286,8 @@ mod tests { fn communicating_between_dialer_and_listener() { let temp_dir = tempfile::tempdir().unwrap(); let socket = temp_dir.path().join("socket"); - let addr = Multiaddr::from(Protocol::Unix(Cow::Owned( - socket.to_string_lossy().into_owned(), - ))); + let addr = + Multiaddr::from(Protocol::Unix(Cow::Owned(socket.to_string_lossy().into_owned()))); let (tx, rx) = oneshot::channel(); diff --git a/transports/webrtc-websys/src/connection.rs b/transports/webrtc-websys/src/connection.rs index b858237da63..409d73c2e70 100644 --- a/transports/webrtc-websys/src/connection.rs +++ b/transports/webrtc-websys/src/connection.rs @@ -46,20 +46,23 @@ impl Connection { // An ondatachannel Future enables us to poll for incoming data channel events in poll_incoming let (mut tx_ondatachannel, rx_ondatachannel) = mpsc::channel(4); // we may get more than one data channel opened on a single peer connection - let ondatachannel_closure = Closure::new(move |ev: RtcDataChannelEvent| { - tracing::trace!("New data channel"); - - if let Err(e) = tx_ondatachannel.try_send(ev.channel()) { - if e.is_full() { - tracing::warn!("Remote is opening too many data channels, we can't keep up!"); - return; - } - - if e.is_disconnected() { - tracing::warn!("Receiver is gone, are we shutting down?"); + let ondatachannel_closure = + Closure::new(move |ev: RtcDataChannelEvent| { + tracing::trace!("New data channel"); + + if let Err(e) = tx_ondatachannel.try_send(ev.channel()) { + if e.is_full() { + tracing::warn!( + "Remote is opening too many data channels, we can't keep up!" + ); + return; + } + + if e.is_disconnected() { + tracing::warn!("Receiver is gone, are we shutting down?"); + } } - } - }); + }); peer_connection .inner .set_ondatachannel(Some(ondatachannel_closure.as_ref().unchecked_ref())); diff --git a/transports/webrtc-websys/src/stream/poll_data_channel.rs b/transports/webrtc-websys/src/stream/poll_data_channel.rs index 0ee4f7920c9..6633fae7b2a 100644 --- a/transports/webrtc-websys/src/stream/poll_data_channel.rs +++ b/transports/webrtc-websys/src/stream/poll_data_channel.rs @@ -61,14 +61,15 @@ impl PollDataChannel { let write_waker = Rc::new(AtomicWaker::new()); inner.set_buffered_amount_low_threshold(0); - let on_write_closure = Closure::new({ - let write_waker = write_waker.clone(); + let on_write_closure = + Closure::new({ + let write_waker = write_waker.clone(); - move |_: Event| { - tracing::trace!("DataChannel available for writing (again)"); - write_waker.wake(); - } - }); + move |_: Event| { + tracing::trace!("DataChannel available for writing (again)"); + write_waker.wake(); + } + }); inner.set_onbufferedamountlow(Some(on_write_closure.as_ref().unchecked_ref())); let close_waker = Rc::new(AtomicWaker::new()); diff --git a/transports/webrtc-websys/src/transport.rs b/transports/webrtc-websys/src/transport.rs index ecf137eab8a..ced338d9f8f 100644 --- a/transports/webrtc-websys/src/transport.rs +++ b/transports/webrtc-websys/src/transport.rs @@ -113,10 +113,11 @@ impl libp2p_core::Transport for Transport { /// See: `` for more details fn maybe_local_firefox() -> bool { let window = &web_sys::window().expect("window should be available"); - let ua = match window.navigator().user_agent() { - Ok(agent) => agent.to_lowercase(), - Err(_) => return false, - }; + let ua = + match window.navigator().user_agent() { + Ok(agent) => agent.to_lowercase(), + Err(_) => return false, + }; let hostname = match window .document() diff --git a/transports/webrtc/src/tokio/certificate.rs b/transports/webrtc/src/tokio/certificate.rs index 7c7c65f0447..9980d20aded 100644 --- a/transports/webrtc/src/tokio/certificate.rs +++ b/transports/webrtc/src/tokio/certificate.rs @@ -36,9 +36,8 @@ impl Certificate { where R: CryptoRng + Rng, { - let mut params = rcgen::CertificateParams::new(vec![ - rand::distributions::Alphanumeric.sample_string(&mut rand::thread_rng(), 16) - ]); + let mut params = rcgen::CertificateParams::new(vec![rand::distributions::Alphanumeric + .sample_string(&mut rand::thread_rng(), 16)]); params.alg = &rcgen::PKCS_ECDSA_P256_SHA256; Ok(Self { inner: RTCCertificate::from_params(params).expect("default params to work"), diff --git a/transports/webrtc/src/tokio/fingerprint.rs b/transports/webrtc/src/tokio/fingerprint.rs index c075e486232..62f8adf25e4 100644 --- a/transports/webrtc/src/tokio/fingerprint.rs +++ b/transports/webrtc/src/tokio/fingerprint.rs @@ -53,9 +53,7 @@ impl Fingerprint { /// Converts [`Multihash`](multihash::Multihash) to [`Fingerprint`]. pub fn try_from_multihash(hash: Multihash) -> Option { - Some(Self(libp2p_webrtc_utils::Fingerprint::try_from_multihash( - hash, - )?)) + Some(Self(libp2p_webrtc_utils::Fingerprint::try_from_multihash(hash)?)) } /// Converts this fingerprint to [`Multihash`](multihash::Multihash). diff --git a/transports/webrtc/src/tokio/sdp.rs b/transports/webrtc/src/tokio/sdp.rs index 8549a864dcc..f7edc2132d0 100644 --- a/transports/webrtc/src/tokio/sdp.rs +++ b/transports/webrtc/src/tokio/sdp.rs @@ -42,12 +42,13 @@ pub(crate) fn answer( /// /// Certificate verification is disabled which is why we hardcode a dummy fingerprint here. pub(crate) fn offer(addr: SocketAddr, client_ufrag: &str) -> RTCSessionDescription { - let offer = render_description( - CLIENT_SESSION_DESCRIPTION, - addr, - Fingerprint::FF, - client_ufrag, - ); + let offer = + render_description( + CLIENT_SESSION_DESCRIPTION, + addr, + Fingerprint::FF, + client_ufrag, + ); tracing::trace!(offer=%offer, "Created SDP offer"); diff --git a/transports/webrtc/src/tokio/udp_mux.rs b/transports/webrtc/src/tokio/udp_mux.rs index 20e04edaf72..ba45cccb9e5 100644 --- a/transports/webrtc/src/tokio/udp_mux.rs +++ b/transports/webrtc/src/tokio/udp_mux.rs @@ -247,13 +247,14 @@ impl UDPMuxNewAddr { continue; } - let muxed_conn = match self.create_muxed_conn(&ufrag) { - Ok(conn) => conn, - Err(e) => { - let _ = response.send(Err(e)); - continue; - } - }; + let muxed_conn = + match self.create_muxed_conn(&ufrag) { + Ok(conn) => conn, + Err(e) => { + let _ = response.send(Err(e)); + continue; + } + }; let mut close_rx = muxed_conn.close_rx(); self.close_futures.push({ @@ -437,11 +438,12 @@ impl UdpMuxHandle { let (sender2, receiver2) = req_res_chan::new(1); let (sender3, receiver3) = req_res_chan::new(1); - let this = Self { - close_sender: sender1, - get_conn_sender: sender2, - remove_sender: sender3, - }; + let this = + Self { + close_sender: sender1, + get_conn_sender: sender2, + remove_sender: sender3, + }; (this, receiver1, receiver2, receiver3) } @@ -550,9 +552,9 @@ fn ufrag_from_stun_message(buffer: &[u8], local_ufrag: bool) -> Result Err(Error::Other(format!( - "failed to decode USERNAME from STUN message as UTF-8: {err}" - ))), + Err(err) => Err( + Error::Other(format!("failed to decode USERNAME from STUN message as UTF-8: {err}")) + ), Ok(s) => { // s is a combination of the local_ufrag and the remote ufrag separated by `:`. let res = if local_ufrag { diff --git a/transports/webrtc/src/tokio/upgrade.rs b/transports/webrtc/src/tokio/upgrade.rs index 4145a5e7510..d6ce39a7ec4 100644 --- a/transports/webrtc/src/tokio/upgrade.rs +++ b/transports/webrtc/src/tokio/upgrade.rs @@ -115,11 +115,12 @@ async fn new_outbound_connection( let ufrag = random_ufrag(); let se = setting_engine(udp_mux, &ufrag, addr); - let connection = APIBuilder::new() - .with_setting_engine(se) - .build() - .new_peer_connection(config) - .await?; + let connection = + APIBuilder::new() + .with_setting_engine(se) + .build() + .new_peer_connection(config) + .await?; Ok((connection, ufrag)) } @@ -141,11 +142,12 @@ async fn new_inbound_connection( se.set_answering_dtls_role(DTLSRole::Server)?; } - let connection = APIBuilder::new() - .with_setting_engine(se) - .build() - .new_peer_connection(config) - .await?; + let connection = + APIBuilder::new() + .with_setting_engine(se) + .build() + .new_peer_connection(config) + .await?; Ok(connection) } diff --git a/transports/webrtc/tests/smoke.rs b/transports/webrtc/tests/smoke.rs index 76e168edfd6..ae647ddac12 100644 --- a/transports/webrtc/tests/smoke.rs +++ b/transports/webrtc/tests/smoke.rs @@ -357,14 +357,15 @@ impl Future for ListenUpgrade<'_> { send_back_addr, .. })) => { - self.listener_upgrade_task = Some( - async move { - let (peer, conn) = upgrade.await.unwrap(); - - (peer, send_back_addr, conn) - } - .boxed(), - ); + self.listener_upgrade_task = + Some( + async move { + let (peer, conn) = upgrade.await.unwrap(); + + (peer, send_back_addr, conn) + } + .boxed(), + ); continue; } Poll::Ready(None) => unreachable!("stream never ends"), diff --git a/transports/websocket-websys/src/lib.rs b/transports/websocket-websys/src/lib.rs index b4f7566f95e..f659fae0e1a 100644 --- a/transports/websocket-websys/src/lib.rs +++ b/transports/websocket-websys/src/lib.rs @@ -135,11 +135,12 @@ fn extract_websocket_url(addr: &Multiaddr) -> Option { _ => return None, }; - let (scheme, wspath) = match protocols.next() { - Some(Protocol::Ws(path)) => ("ws", path.into_owned()), - Some(Protocol::Wss(path)) => ("wss", path.into_owned()), - _ => return None, - }; + let (scheme, wspath) = + match protocols.next() { + Some(Protocol::Ws(path)) => ("ws", path.into_owned()), + Some(Protocol::Wss(path)) => ("wss", path.into_owned()), + _ => return None, + }; Some(format!("{scheme}://{host_port}{wspath}")) } @@ -258,12 +259,13 @@ impl Connection { socket.set_onclose(Some(onclose_closure.as_ref().unchecked_ref())); let errored = Rc::new(AtomicBool::new(false)); - let onerror_closure = Closure::::new({ - let errored = errored.clone(); - move |_| { - errored.store(true, Ordering::SeqCst); - } - }); + let onerror_closure = + Closure::::new({ + let errored = errored.clone(); + move |_| { + errored.store(true, Ordering::SeqCst); + } + }); socket.set_onerror(Some(onerror_closure.as_ref().unchecked_ref())); let read_buffer = Rc::new(Mutex::new(BytesMut::new())); diff --git a/transports/websocket/src/quicksink.rs b/transports/websocket/src/quicksink.rs index d9edb4dfe0d..481170ba19b 100644 --- a/transports/websocket/src/quicksink.rs +++ b/transports/websocket/src/quicksink.rs @@ -183,19 +183,20 @@ where return Poll::Ready(Ok(())); } } - State::Sending => match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) - { - Ok(p) => { - this.future.set(None); - *this.param = Some(p); - *this.state = State::Empty - } - Err(e) => { - this.future.set(None); - *this.state = State::Failed; - return Poll::Ready(Err(e)); + State::Sending => { + match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) { + Ok(p) => { + this.future.set(None); + *this.param = Some(p); + *this.state = State::Empty + } + Err(e) => { + this.future.set(None); + *this.state = State::Failed; + return Poll::Ready(Err(e)); + } } - }, + } State::Flushing => { match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) { Ok(p) => { @@ -243,19 +244,20 @@ where return Poll::Ready(Ok(())); } } - State::Sending => match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) - { - Ok(p) => { - this.future.set(None); - *this.param = Some(p); - *this.state = State::Empty - } - Err(e) => { - this.future.set(None); - *this.state = State::Failed; - return Poll::Ready(Err(e)); + State::Sending => { + match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) { + Ok(p) => { + this.future.set(None); + *this.param = Some(p); + *this.state = State::Empty + } + Err(e) => { + this.future.set(None); + *this.state = State::Failed; + return Poll::Ready(Err(e)); + } } - }, + } State::Flushing => { match ready!(this.future.as_mut().as_pin_mut().unwrap().poll(cx)) { Ok(p) => { diff --git a/transports/webtransport-websys/src/bindings.rs b/transports/webtransport-websys/src/bindings.rs index a8a1469f8ad..dc4e965d5d5 100644 --- a/transports/webtransport-websys/src/bindings.rs +++ b/transports/webtransport-websys/src/bindings.rs @@ -116,11 +116,12 @@ impl WebTransportHash { } pub fn algorithm(&mut self, val: &str) -> &mut Self { - let r = Reflect::set( - self.as_ref(), - &JsValue::from("algorithm"), - &JsValue::from(val), - ); + let r = + Reflect::set( + self.as_ref(), + &JsValue::from("algorithm"), + &JsValue::from(val), + ); debug_assert!( r.is_ok(), "setting properties should never fail on our dictionary objects" diff --git a/transports/webtransport-websys/src/endpoint.rs b/transports/webtransport-websys/src/endpoint.rs index 0bff1ed6186..65f0603b29d 100644 --- a/transports/webtransport-websys/src/endpoint.rs +++ b/transports/webtransport-websys/src/endpoint.rs @@ -50,9 +50,9 @@ impl Endpoint { host = Some(domain.to_string()) } Protocol::Dnsaddr(_) => { - return Err(Error::InvalidMultiaddr( - "/dnsaddr not supported from within a browser", - )); + return Err( + Error::InvalidMultiaddr("/dnsaddr not supported from within a browser") + ); } Protocol::Udp(p) => { if port.is_some() { @@ -72,9 +72,9 @@ impl Endpoint { } Protocol::WebTransport => { if !found_quic { - return Err(Error::InvalidMultiaddr( - "/quic is not found before /webtransport", - )); + return Err( + Error::InvalidMultiaddr("/quic is not found before /webtransport") + ); } found_webtransport = true; @@ -100,9 +100,7 @@ impl Endpoint { } if !found_quic || !found_webtransport { - return Err(Error::InvalidMultiaddr( - "Not a /quic/webtransport multiaddr", - )); + return Err(Error::InvalidMultiaddr("Not a /quic/webtransport multiaddr")); } let host = host.ok_or_else(|| Error::InvalidMultiaddr("Host is not defined"))?; @@ -166,13 +164,13 @@ mod tests { assert_eq!(endpoint.port, 44874); assert_eq!(endpoint.certhashes.len(), 2); - assert!(endpoint.certhashes.contains(&multihash_from_str( - "uEiCaDd1Ca1A8IVJ3hsIxIyi11cwxaDKqzVrBkGJbKZU5ng" - ))); + assert!(endpoint + .certhashes + .contains(&multihash_from_str("uEiCaDd1Ca1A8IVJ3hsIxIyi11cwxaDKqzVrBkGJbKZU5ng"))); - assert!(endpoint.certhashes.contains(&multihash_from_str( - "uEiDv-VGW8oXxui_G_Kqp-87YjvET-Hr2qYAMYPePJDcsjQ" - ))); + assert!(endpoint + .certhashes + .contains(&multihash_from_str("uEiDv-VGW8oXxui_G_Kqp-87YjvET-Hr2qYAMYPePJDcsjQ"))); assert_eq!( endpoint.remote_peer.unwrap(), diff --git a/transports/webtransport-websys/src/stream.rs b/transports/webtransport-websys/src/stream.rs index ba4238ac814..278618ea14c 100644 --- a/transports/webtransport-websys/src/stream.rs +++ b/transports/webtransport-websys/src/stream.rs @@ -78,16 +78,17 @@ impl StreamInner { fn poll_read(&mut self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll> { // If we have leftovers from a previous read, then use them. // Otherwise read new data. - let data = match self.read_leftovers.take() { - Some(data) => data, - None => { - match ready!(self.poll_reader_read(cx))? { - Some(data) => data, - // EOF - None => return Poll::Ready(Ok(0)), + let data = + match self.read_leftovers.take() { + Some(data) => data, + None => { + match ready!(self.poll_reader_read(cx))? { + Some(data) => data, + // EOF + None => return Poll::Ready(Ok(0)), + } } - } - }; + }; if data.byte_length() == 0 { return Poll::Ready(Ok(0)); From b6c48a8a4815df0651540a45868841c0f1908887 Mon Sep 17 00:00:00 2001 From: umgefahren <55623006+umgefahren@users.noreply.github.com> Date: Mon, 20 Nov 2023 16:34:43 +0100 Subject: [PATCH 2/2] Run clippy --- muxers/mplex/src/io.rs | 6 +++--- protocols/relay/src/behaviour/rate_limiter.rs | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/muxers/mplex/src/io.rs b/muxers/mplex/src/io.rs index 014a27612a6..9f63cf91281 100644 --- a/muxers/mplex/src/io.rs +++ b/muxers/mplex/src/io.rs @@ -224,7 +224,7 @@ where // yield to give the current task a chance to read // from the respective substreams. if num_buffered == self.config.max_buffer_len { - cx.waker().clone().wake(); + cx.waker().wake_by_ref(); return Poll::Pending; } @@ -456,7 +456,7 @@ where // next frame for `id`, yield to give the current task // a chance to read from the other substream(s). if num_buffered == self.config.max_buffer_len { - cx.waker().clone().wake(); + cx.waker().wake_by_ref(); return Poll::Pending; } @@ -663,7 +663,7 @@ where connection=%self.id, "No task to read from blocked stream. Waking current task." ); - cx.waker().clone().wake(); + cx.waker().wake_by_ref(); } else if let Some(id) = stream_id { // We woke some other task, but are still interested in // reading `Data` frames from the current stream when unblocked. diff --git a/protocols/relay/src/behaviour/rate_limiter.rs b/protocols/relay/src/behaviour/rate_limiter.rs index 7dc57a95bb2..d8df49c2174 100644 --- a/protocols/relay/src/behaviour/rate_limiter.rs +++ b/protocols/relay/src/behaviour/rate_limiter.rs @@ -126,7 +126,7 @@ impl GenericRateLimiter { // Note when used with a high number of buckets: This loop refills all the to-be-refilled // buckets at once, thus potentially delaying the parent call to `try_next`. loop { - match self.refill_schedule.get(0) { + match self.refill_schedule.front() { // Only continue if (a) there is a bucket and (b) the bucket has not already been // refilled recently. Some((last_refill, _)) if now.duration_since(*last_refill) >= self.interval => {}