Apply cargo fmt

transports/quic/src/crypto.rs

@@ -18,7 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use libp2p_core::identity::{PublicKey, Keypair};
+use libp2p_core::identity::{Keypair, PublicKey};
 use quinn_proto::crypto::Session;
 use quinn_proto::TransportConfig;
 use std::sync::Arc;
@@ -33,7 +33,6 @@ pub struct CryptoConfig {
 pub(crate) struct TlsCrypto;
 
 impl TlsCrypto {
-
     pub fn new_server_config(
         config: &CryptoConfig,
     ) -> <quinn_proto::crypto::rustls::TlsSession as Session>::ServerConfig {

transports/quic/src/endpoint.rs

@@ -23,12 +23,12 @@ use crate::muxer::QuicMuxer;
 use crate::{QuicConfig, QuicError};
 use futures::channel::{mpsc, oneshot};
 use futures::prelude::*;
-use quinn_proto::{ServerConfig as QuinnServerConfig};
-use quinn_proto::generic::{ClientConfig as QuinnClientConfig};
+use libp2p_core::identity::PublicKey;
+use quinn_proto::generic::ClientConfig as QuinnClientConfig;
+use quinn_proto::ServerConfig as QuinnServerConfig;
 use quinn_proto::{
     ConnectionEvent, ConnectionHandle, DatagramEvent, EcnCodepoint, EndpointEvent, Transmit,
 };
-use libp2p_core::identity::PublicKey;
 use std::collections::{HashMap, VecDeque};
 use std::io::IoSliceMut;
 use std::mem::MaybeUninit;
@@ -199,8 +199,10 @@ impl EndpointConfig {
         server_config.crypto = TlsCrypto::new_server_config(&crypto_config);
 
         let mut endpoint_config = QuinnEndpointConfig::default();
-        endpoint_config
-            .supported_versions(TlsCrypto::supported_quic_versions(), TlsCrypto::default_quic_version())?;
+        endpoint_config.supported_versions(
+            TlsCrypto::supported_quic_versions(),
+            TlsCrypto::default_quic_version(),
+        )?;
 
         let socket = UdpSocket::bind(addr)?;
         let port = socket.local_addr()?.port();
@@ -218,8 +220,7 @@ impl EndpointConfig {
         })
     }
 
-    pub fn spawn(self) -> TransportChannel
-    {
+    pub fn spawn(self) -> TransportChannel {
         let (tx1, rx1) = mpsc::unbounded();
         let (tx2, rx2) = mpsc::channel(1);
         let transport = TransportChannel {
@@ -325,8 +326,7 @@ impl Endpoint {
     }
 }
 
-impl Future for Endpoint
-{
+impl Future for Endpoint {
     type Output = ();
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {

transports/quic/src/lib.rs

@@ -29,9 +29,9 @@ pub use crate::muxer::{QuicMuxer, QuicMuxerError};
 pub use crate::transport::{QuicDial, QuicTransport};
 pub use quinn_proto::{ConfigError, ConnectError, ConnectionError, TransportConfig};
 
+use libp2p_core::identity::Keypair;
 use libp2p_core::transport::TransportError;
 use libp2p_core::Multiaddr;
-use libp2p_core::identity::Keypair;
 use std::sync::Arc;
 use thiserror::Error;
 
@@ -51,8 +51,7 @@ impl std::fmt::Debug for QuicConfig {
     }
 }
 
-impl QuicConfig
-{
+impl QuicConfig {
     /// Creates a new config from a keypair.
     pub fn new(keypair: Keypair) -> Self {
         Self {

transports/quic/src/transport.rs

@@ -41,8 +41,7 @@ pub struct QuicTransport {
     inner: Arc<Mutex<QuicTransportInner>>,
 }
 
-impl QuicTransport
-{
+impl QuicTransport {
     /// Creates a new quic transport.
     pub async fn new(
         config: QuicConfig,
@@ -93,17 +92,15 @@ enum Addresses {
     Ip(Option<IpAddr>),
 }
 
-impl Transport for QuicTransport
-{
+impl Transport for QuicTransport {
     type Output = (PeerId, QuicMuxer);
     type Error = QuicError;
     type Listener = Self;
     type ListenerUpgrade = QuicUpgrade;
     type Dial = QuicDial;
 
     fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
-        multiaddr_to_socketaddr(&addr)
-            .map_err(|_| TransportError::MultiaddrNotSupported(addr))?;
+        multiaddr_to_socketaddr(&addr).map_err(|_| TransportError::MultiaddrNotSupported(addr))?;
         Ok(self)
     }
 
@@ -187,8 +184,7 @@ pub enum QuicDial {
     Upgrade(QuicUpgrade),
 }
 
-impl Future for QuicDial
-{
+impl Future for QuicDial {
     type Output = Result<(PeerId, QuicMuxer), QuicError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
@@ -218,8 +214,7 @@ impl QuicUpgrade {
     }
 }
 
-impl Future for QuicUpgrade
-{
+impl Future for QuicUpgrade {
     type Output = Result<(PeerId, QuicMuxer), QuicError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -247,9 +242,7 @@ impl Future for QuicUpgrade
 
 /// Tries to turn a QUIC multiaddress into a UDP [`SocketAddr`]. Returns an error if the format
 /// of the multiaddr is wrong.
-fn multiaddr_to_socketaddr(
-    addr: &Multiaddr,
-) -> Result<(SocketAddr, Option<PublicKey>), ()> {
+fn multiaddr_to_socketaddr(addr: &Multiaddr) -> Result<(SocketAddr, Option<PublicKey>), ()> {
     let mut iter = addr.iter().peekable();
     let proto1 = iter.next().ok_or(())?;
     let proto2 = iter.next().ok_or(())?;
@@ -298,10 +291,10 @@ mod tests {
     fn multiaddr_to_udp_conversion() {
         use std::net::{Ipv4Addr, Ipv6Addr};
 
-        assert!(multiaddr_to_socketaddr(
-            &"/ip4/127.0.0.1/udp/1234".parse::<Multiaddr>().unwrap()
-        )
-        .is_err());
+        assert!(
+            multiaddr_to_socketaddr(&"/ip4/127.0.0.1/udp/1234".parse::<Multiaddr>().unwrap())
+                .is_err()
+        );
 
         assert_eq!(
             multiaddr_to_socketaddr(

transports/quic/tests/smoke.rs

@@ -18,10 +18,7 @@ fn generate_tls_keypair() -> libp2p::identity::Keypair {
     libp2p::identity::Keypair::generate_ed25519()
 }
 
-async fn create_swarm(
-    keylog: bool,
-) -> Result<Swarm<RequestResponse<PingCodec>>>
-{
+async fn create_swarm(keylog: bool) -> Result<Swarm<RequestResponse<PingCodec>>> {
     let keypair = generate_tls_keypair();
     let peer_id = keypair.public().to_peer_id();
     let mut transport = QuicConfig::new(keypair);