chore: introduce rustfmt.toml

Author: jxs

core/src/connection.rs

@@ -70,18 +70,16 @@ pub enum ConnectedPoint {
         ///
         /// - [`Endpoint::Dialer`] represents the default non-overriding option.
         ///
-        /// - [`Endpoint::Listener`] represents the overriding option.
-        ///   Realization depends on the transport protocol. E.g. in the case of
-        ///   TCP, both endpoints dial each other, resulting in a _simultaneous
-        ///   open_ TCP connection. On this new connection both endpoints assume
-        ///   to be the dialer of the connection. This is problematic during the
-        ///   connection upgrade process where an upgrade assumes one side to be
-        ///   the listener. With the help of this option, both peers can
-        ///   negotiate the roles (dialer and listener) for the new connection
-        ///   ahead of time, through some external channel, e.g. the DCUtR
-        ///   protocol, and thus have one peer dial the other and upgrade the
-        ///   connection as a dialer and one peer dial the other and upgrade the
-        ///   connection _as a listener_ overriding its role.
+        /// - [`Endpoint::Listener`] represents the overriding option. Realization depends on the
+        ///   transport protocol. E.g. in the case of TCP, both endpoints dial each other,
+        ///   resulting in a _simultaneous open_ TCP connection. On this new connection both
+        ///   endpoints assume to be the dialer of the connection. This is problematic during the
+        ///   connection upgrade process where an upgrade assumes one side to be the listener. With
+        ///   the help of this option, both peers can negotiate the roles (dialer and listener) for
+        ///   the new connection ahead of time, through some external channel, e.g. the DCUtR
+        ///   protocol, and thus have one peer dial the other and upgrade the connection as a
+        ///   dialer and one peer dial the other and upgrade the connection _as a listener_
+        ///   overriding its role.
         role_override: Endpoint,
         /// Whether the port for the outgoing connection was reused from a listener
         /// or a new port was allocated. This is useful for address translation.

core/src/either.rs

@@ -18,17 +18,20 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::muxing::StreamMuxerEvent;
-use crate::transport::DialOpts;
-use crate::{
-    muxing::StreamMuxer,
-    transport::{ListenerId, Transport, TransportError, TransportEvent},
-    Multiaddr,
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
 };
+
 use either::Either;
 use futures::prelude::*;
 use pin_project::pin_project;
-use std::{pin::Pin, task::Context, task::Poll};
+
+use crate::{
+    muxing::{StreamMuxer, StreamMuxerEvent},
+    transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent},
+    Multiaddr,
+};
 
 impl<A, B> StreamMuxer for future::Either<A, B>
 where

core/src/lib.rs

@@ -22,22 +22,21 @@
 //!
 //! The main concepts of libp2p-core are:
 //!
-//! - The [`Transport`] trait defines how to reach a remote node or listen for
-//!   incoming remote connections. See the [`transport`] module.
-//! - The [`StreamMuxer`] trait is implemented on structs that hold a connection
-//!   to a remote and can subdivide this connection into multiple substreams.
-//!   See the [`muxing`] module.
-//! - The [`UpgradeInfo`], [`InboundUpgrade`] and [`OutboundUpgrade`] traits
-//!   define how to upgrade each individual substream to use a protocol.
-//!   See the `upgrade` module.
+//! - The [`Transport`] trait defines how to reach a remote node or listen for incoming remote
+//!   connections. See the [`transport`] module.
+//! - The [`StreamMuxer`] trait is implemented on structs that hold a connection to a remote and can
+//!   subdivide this connection into multiple substreams. See the [`muxing`] module.
+//! - The [`UpgradeInfo`], [`InboundUpgrade`] and [`OutboundUpgrade`] traits define how to upgrade
+//!   each individual substream to use a protocol. See the `upgrade` module.
 
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
 mod proto {
     #![allow(unreachable_pub)]
     include!("generated/mod.rs");
     pub use self::{
-        envelope_proto::*, peer_record_proto::mod_PeerRecord::*, peer_record_proto::PeerRecord,
+        envelope_proto::*,
+        peer_record_proto::{mod_PeerRecord::*, PeerRecord},
     };
 }
 

core/src/muxing.rs

@@ -20,63 +20,75 @@
 
 //! Muxing is the process of splitting a connection into multiple substreams.
 //!
-//! The main item of this module is the `StreamMuxer` trait. An implementation of `StreamMuxer`
-//! has ownership of a connection, lets you open and close substreams.
+//! The main item of this module is the `StreamMuxer` trait. An implementation
+//! of `StreamMuxer` has ownership of a connection, lets you open and close
+//! substreams.
 //!
-//! > **Note**: You normally don't need to use the methods of the `StreamMuxer` directly, as this
-//! >           is managed by the library's internals.
+//! > **Note**: You normally don't need to use the methods of the `StreamMuxer`
+//! > directly, as this
+//! > is managed by the library's internals.
 //!
-//! Each substream of a connection is an isolated stream of data. All the substreams are muxed
-//! together so that the data read from or written to each substream doesn't influence the other
-//! substreams.
+//! Each substream of a connection is an isolated stream of data. All the
+//! substreams are muxed together so that the data read from or written to each
+//! substream doesn't influence the other substreams.
 //!
-//! In the context of libp2p, each substream can use a different protocol. Contrary to opening a
-//! connection, opening a substream is almost free in terms of resources. This means that you
-//! shouldn't hesitate to rapidly open and close substreams, and to design protocols that don't
-//! require maintaining long-lived channels of communication.
+//! In the context of libp2p, each substream can use a different protocol.
+//! Contrary to opening a connection, opening a substream is almost free in
+//! terms of resources. This means that you shouldn't hesitate to rapidly open
+//! and close substreams, and to design protocols that don't require maintaining
+//! long-lived channels of communication.
 //!
-//! > **Example**: The Kademlia protocol opens a new substream for each request it wants to
-//! >              perform. Multiple requests can be performed simultaneously by opening multiple
-//! >              substreams, without having to worry about associating responses with the
-//! >              right request.
+//! > **Example**: The Kademlia protocol opens a new substream for each request
+//! > it wants to
+//! > perform. Multiple requests can be performed simultaneously by opening
+//! > multiple
+//! > substreams, without having to worry about associating responses with the
+//! > right request.
 //!
 //! # Implementing a muxing protocol
 //!
-//! In order to implement a muxing protocol, create an object that implements the `UpgradeInfo`,
-//! `InboundUpgrade` and `OutboundUpgrade` traits. See the `upgrade` module for more information.
-//! The `Output` associated type of the `InboundUpgrade` and `OutboundUpgrade` traits should be
-//! identical, and should be an object that implements the `StreamMuxer` trait.
+//! In order to implement a muxing protocol, create an object that implements
+//! the `UpgradeInfo`, `InboundUpgrade` and `OutboundUpgrade` traits. See the
+//! `upgrade` module for more information. The `Output` associated type of the
+//! `InboundUpgrade` and `OutboundUpgrade` traits should be identical, and
+//! should be an object that implements the `StreamMuxer` trait.
 //!
-//! The upgrade process will take ownership of the connection, which makes it possible for the
-//! implementation of `StreamMuxer` to control everything that happens on the wire.
+//! The upgrade process will take ownership of the connection, which makes it
+//! possible for the implementation of `StreamMuxer` to control everything that
+//! happens on the wire.
+
+use std::{future::Future, pin::Pin};
 
-use futures::{task::Context, task::Poll, AsyncRead, AsyncWrite};
+use futures::{
+    task::{Context, Poll},
+    AsyncRead, AsyncWrite,
+};
 use multiaddr::Multiaddr;
-use std::future::Future;
-use std::pin::Pin;
 
-pub use self::boxed::StreamMuxerBox;
-pub use self::boxed::SubstreamBox;
+pub use self::boxed::{StreamMuxerBox, SubstreamBox};
 
 mod boxed;
 
 /// Provides multiplexing for a connection by allowing users to open substreams.
 ///
-/// A substream created by a [`StreamMuxer`] is a type that implements [`AsyncRead`] and [`AsyncWrite`].
-/// The [`StreamMuxer`] itself is modelled closely after [`AsyncWrite`]. It features `poll`-style
-/// functions that allow the implementation to make progress on various tasks.
+/// A substream created by a [`StreamMuxer`] is a type that implements
+/// [`AsyncRead`] and [`AsyncWrite`]. The [`StreamMuxer`] itself is modelled
+/// closely after [`AsyncWrite`]. It features `poll`-style functions that allow
+/// the implementation to make progress on various tasks.
 pub trait StreamMuxer {
-    /// Type of the object that represents the raw substream where data can be read and written.
+    /// Type of the object that represents the raw substream where data can be
+    /// read and written.
     type Substream: AsyncRead + AsyncWrite;
 
     /// Error type of the muxer
     type Error: std::error::Error;
 
     /// Poll for new inbound substreams.
     ///
-    /// This function should be called whenever callers are ready to accept more inbound streams. In
-    /// other words, callers may exercise back-pressure on incoming streams by not calling this
-    /// function if a certain limit is hit.
+    /// This function should be called whenever callers are ready to accept more
+    /// inbound streams. In other words, callers may exercise back-pressure
+    /// on incoming streams by not calling this function
+    /// if a certain limit is hit.
     fn poll_inbound(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -90,20 +102,23 @@ pub trait StreamMuxer {
 
     /// Poll to close this [`StreamMuxer`].
     ///
-    /// After this has returned `Poll::Ready(Ok(()))`, the muxer has become useless and may be safely
-    /// dropped.
+    /// After this has returned `Poll::Ready(Ok(()))`, the muxer has become
+    /// useless and may be safely dropped.
     ///
-    /// > **Note**: You are encouraged to call this method and wait for it to return `Ready`, so
-    /// >           that the remote is properly informed of the shutdown. However, apart from
-    /// >           properly informing the remote, there is no difference between this and
-    /// >           immediately dropping the muxer.
+    /// > **Note**: You are encouraged to call this method and wait for it to
+    /// > return `Ready`, so
+    /// > that the remote is properly informed of the shutdown. However, apart
+    /// > from
+    /// > properly informing the remote, there is no difference between this and
+    /// > immediately dropping the muxer.
     fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Poll to allow the underlying connection to make progress.
     ///
-    /// In contrast to all other `poll`-functions on [`StreamMuxer`], this function MUST be called
-    /// unconditionally. Because it will be called regardless, this function can be used by
-    /// implementations to return events about the underlying connection that the caller MUST deal
+    /// In contrast to all other `poll`-functions on [`StreamMuxer`], this
+    /// function MUST be called unconditionally. Because it will be called
+    /// regardless, this function can be used by implementations to return
+    /// events about the underlying connection that the caller MUST deal
     /// with.
     fn poll(
         self: Pin<&mut Self>,
@@ -120,7 +135,8 @@ pub enum StreamMuxerEvent {
 
 /// Extension trait for [`StreamMuxer`].
 pub trait StreamMuxerExt: StreamMuxer + Sized {
-    /// Convenience function for calling [`StreamMuxer::poll_inbound`] for [`StreamMuxer`]s that are `Unpin`.
+    /// Convenience function for calling [`StreamMuxer::poll_inbound`] for
+    /// [`StreamMuxer`]s that are `Unpin`.
     fn poll_inbound_unpin(
         &mut self,
         cx: &mut Context<'_>,
@@ -131,7 +147,8 @@ pub trait StreamMuxerExt: StreamMuxer + Sized {
         Pin::new(self).poll_inbound(cx)
     }
 
-    /// Convenience function for calling [`StreamMuxer::poll_outbound`] for [`StreamMuxer`]s that are `Unpin`.
+    /// Convenience function for calling [`StreamMuxer::poll_outbound`] for
+    /// [`StreamMuxer`]s that are `Unpin`.
     fn poll_outbound_unpin(
         &mut self,
         cx: &mut Context<'_>,
@@ -142,15 +159,17 @@ pub trait StreamMuxerExt: StreamMuxer + Sized {
         Pin::new(self).poll_outbound(cx)
     }
 
-    /// Convenience function for calling [`StreamMuxer::poll`] for [`StreamMuxer`]s that are `Unpin`.
+    /// Convenience function for calling [`StreamMuxer::poll`] for
+    /// [`StreamMuxer`]s that are `Unpin`.
     fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Result<StreamMuxerEvent, Self::Error>>
     where
         Self: Unpin,
     {
         Pin::new(self).poll(cx)
     }
 
-    /// Convenience function for calling [`StreamMuxer::poll_close`] for [`StreamMuxer`]s that are `Unpin`.
+    /// Convenience function for calling [`StreamMuxer::poll_close`] for
+    /// [`StreamMuxer`]s that are `Unpin`.
     fn poll_close_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
     where
         Self: Unpin,

core/src/muxing/boxed.rs

@@ -1,12 +1,15 @@
-use crate::muxing::{StreamMuxer, StreamMuxerEvent};
+use std::{
+    error::Error,
+    fmt, io,
+    io::{IoSlice, IoSliceMut},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
 use futures::{AsyncRead, AsyncWrite};
 use pin_project::pin_project;
-use std::error::Error;
-use std::fmt;
-use std::io;
-use std::io::{IoSlice, IoSliceMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
+
+use crate::muxing::{StreamMuxer, StreamMuxerEvent};
 
 /// Abstract `StreamMuxer`.
 pub struct StreamMuxerBox {
@@ -21,8 +24,8 @@ impl fmt::Debug for StreamMuxerBox {
 
 /// Abstract type for asynchronous reading and writing.
 ///
-/// A [`SubstreamBox`] erases the concrete type it is given and only retains its `AsyncRead`
-/// and `AsyncWrite` capabilities.
+/// A [`SubstreamBox`] erases the concrete type it is given and only retains its
+/// `AsyncRead` and `AsyncWrite` capabilities.
 pub struct SubstreamBox(Pin<Box<dyn AsyncReadWrite + Send>>);
 
 #[pin_project]
@@ -139,7 +142,8 @@ impl StreamMuxer for StreamMuxerBox {
 }
 
 impl SubstreamBox {
-    /// Construct a new [`SubstreamBox`] from something that implements [`AsyncRead`] and [`AsyncWrite`].
+    /// Construct a new [`SubstreamBox`] from something that implements
+    /// [`AsyncRead`] and [`AsyncWrite`].
     pub fn new<S: AsyncRead + AsyncWrite + Send + 'static>(stream: S) -> Self {
         Self(Box::pin(stream))
     }
@@ -155,7 +159,8 @@ impl fmt::Debug for SubstreamBox {
 trait AsyncReadWrite: AsyncRead + AsyncWrite {
     /// Helper function to capture the erased inner type.
     ///
-    /// Used to make the [`Debug`] implementation of [`SubstreamBox`] more useful.
+    /// Used to make the [`Debug`] implementation of [`SubstreamBox`] more
+    /// useful.
     fn type_name(&self) -> &'static str;
 }
 

core/src/peer_record.rs

@@ -1,18 +1,16 @@
-use crate::signed_envelope::SignedEnvelope;
-use crate::{proto, signed_envelope, DecodeError, Multiaddr};
-use libp2p_identity::Keypair;
-use libp2p_identity::PeerId;
-use libp2p_identity::SigningError;
+use libp2p_identity::{Keypair, PeerId, SigningError};
 use quick_protobuf::{BytesReader, Writer};
 use web_time::SystemTime;
 
+use crate::{proto, signed_envelope, signed_envelope::SignedEnvelope, DecodeError, Multiaddr};
+
 const PAYLOAD_TYPE: &str = "/libp2p/routing-state-record";
 const DOMAIN_SEP: &str = "libp2p-routing-state";
 
 /// Represents a peer routing record.
 ///
-/// Peer records are designed to be distributable and carry a signature by being wrapped in a signed envelope.
-/// For more information see RFC0003 of the libp2p specifications: <https://github.com/libp2p/specs/blob/master/RFC/0003-routing-records.md>
+/// Peer records are designed to be distributable and carry a signature by being
+/// wrapped in a signed envelope. For more information see RFC0003 of the libp2p specifications: <https://github.com/libp2p/specs/blob/master/RFC/0003-routing-records.md>
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct PeerRecord {
     peer_id: PeerId,
@@ -21,14 +19,16 @@ pub struct PeerRecord {
 
     /// A signed envelope representing this [`PeerRecord`].
     ///
-    /// If this [`PeerRecord`] was constructed from a [`SignedEnvelope`], this is the original instance.
+    /// If this [`PeerRecord`] was constructed from a [`SignedEnvelope`], this
+    /// is the original instance.
     envelope: SignedEnvelope,
 }
 
 impl PeerRecord {
     /// Attempt to re-construct a [`PeerRecord`] from a [`SignedEnvelope`].
     ///
-    /// If this function succeeds, the [`SignedEnvelope`] contained a peer record with a valid signature and can hence be considered authenticated.
+    /// If this function succeeds, the [`SignedEnvelope`] contained a peer
+    /// record with a valid signature and can hence be considered authenticated.
     pub fn from_signed_envelope(envelope: SignedEnvelope) -> Result<Self, FromEnvelopeError> {
         use quick_protobuf::MessageRead;
 
@@ -58,9 +58,12 @@ impl PeerRecord {
         })
     }
 
-    /// Construct a new [`PeerRecord`] by authenticating the provided addresses with the given key.
+    /// Construct a new [`PeerRecord`] by authenticating the provided addresses
+    /// with the given key.
     ///
-    /// This is the same key that is used for authenticating every libp2p connection of your application, i.e. what you use when setting up your [`crate::transport::Transport`].
+    /// This is the same key that is used for authenticating every libp2p
+    /// connection of your application, i.e. what you use when setting up your
+    /// [`crate::transport::Transport`].
     pub fn new(key: &Keypair, addresses: Vec<Multiaddr>) -> Result<Self, SigningError> {
         use quick_protobuf::MessageWrite;