*: Format with rustfmt (#2188)

Co-authored-by: Thomas Eizinger <thomas@eizinger.io>

core/src/network/event.rs

@@ -21,20 +21,12 @@
 //! Network events and associated information.
 
 use crate::{
-    Multiaddr,
     connection::{
-        ConnectionId,
-        ConnectedPoint,
-        ConnectionError,
-        ConnectionHandler,
-        Connected,
-        EstablishedConnection,
-        IntoConnectionHandler,
-        ListenerId,
-        PendingConnectionError,
+        Connected, ConnectedPoint, ConnectionError, ConnectionHandler, ConnectionId,
+        EstablishedConnection, IntoConnectionHandler, ListenerId, PendingConnectionError,
     },
     transport::Transport,
-    PeerId
+    Multiaddr, PeerId,
 };
 use std::{fmt, num::NonZeroU32};
 
@@ -60,7 +52,7 @@ where
         /// The listener that errored.
         listener_id: ListenerId,
         /// The listener error.
-        error: TTrans::Error
+        error: TTrans::Error,
     },
 
     /// One of the listeners is now listening on an additional address.
@@ -68,7 +60,7 @@ where
         /// The listener that is listening on the new address.
         listener_id: ListenerId,
         /// The new address the listener is now also listening on.
-        listen_addr: Multiaddr
+        listen_addr: Multiaddr,
     },
 
     /// One of the listeners is no longer listening on some address.
@@ -76,7 +68,7 @@ where
         /// The listener that is no longer listening on some address.
         listener_id: ListenerId,
         /// The expired address.
-        listen_addr: Multiaddr
+        listen_addr: Multiaddr,
     },
 
     /// A new connection arrived on a listener.
@@ -177,8 +169,8 @@ where
     },
 }
 
-impl<TTrans, TInEvent, TOutEvent, THandler> fmt::Debug for
-    NetworkEvent<'_, TTrans, TInEvent, TOutEvent, THandler>
+impl<TTrans, TInEvent, TOutEvent, THandler> fmt::Debug
+    for NetworkEvent<'_, TTrans, TInEvent, TOutEvent, THandler>
 where
     TInEvent: fmt::Debug,
     TOutEvent: fmt::Debug,
@@ -189,83 +181,101 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
-            NetworkEvent::NewListenerAddress { listener_id, listen_addr } => {
-                f.debug_struct("NewListenerAddress")
-                    .field("listener_id", listener_id)
-                    .field("listen_addr", listen_addr)
-                    .finish()
-            }
-            NetworkEvent::ExpiredListenerAddress { listener_id, listen_addr } => {
-                f.debug_struct("ExpiredListenerAddress")
-                    .field("listener_id", listener_id)
-                    .field("listen_addr", listen_addr)
-                    .finish()
-            }
-            NetworkEvent::ListenerClosed { listener_id, addresses, reason } => {
-                f.debug_struct("ListenerClosed")
-                    .field("listener_id", listener_id)
-                    .field("addresses", addresses)
-                    .field("reason", reason)
-                    .finish()
-            }
-            NetworkEvent::ListenerError { listener_id, error } => {
-                f.debug_struct("ListenerError")
-                    .field("listener_id", listener_id)
-                    .field("error", error)
-                    .finish()
-            }
-            NetworkEvent::IncomingConnection { connection, .. } => {
-                f.debug_struct("IncomingConnection")
-                    .field("local_addr", &connection.local_addr)
-                    .field("send_back_addr", &connection.send_back_addr)
-                    .finish()
-            }
-            NetworkEvent::IncomingConnectionError { local_addr, send_back_addr, error } => {
-                f.debug_struct("IncomingConnectionError")
-                    .field("local_addr", local_addr)
-                    .field("send_back_addr", send_back_addr)
-                    .field("error", error)
-                    .finish()
-            }
-            NetworkEvent::ConnectionEstablished { connection, .. } => {
-                f.debug_struct("ConnectionEstablished")
-                    .field("connection", connection)
-                    .finish()
-            }
-            NetworkEvent::ConnectionClosed { id, connected, error, .. } => {
-                f.debug_struct("ConnectionClosed")
-                    .field("id", id)
-                    .field("connected", connected)
-                    .field("error", error)
-                    .finish()
-            }
-            NetworkEvent::DialError { attempts_remaining, peer_id, multiaddr, error } => {
-                f.debug_struct("DialError")
-                    .field("attempts_remaining", attempts_remaining)
-                    .field("peer_id", peer_id)
-                    .field("multiaddr", multiaddr)
-                    .field("error", error)
-                    .finish()
-            }
-            NetworkEvent::UnknownPeerDialError { multiaddr, error, .. } => {
-                f.debug_struct("UnknownPeerDialError")
-                    .field("multiaddr", multiaddr)
-                    .field("error", error)
-                    .finish()
-            }
-            NetworkEvent::ConnectionEvent { connection, event } => {
-                f.debug_struct("ConnectionEvent")
-                    .field("connection", connection)
-                    .field("event", event)
-                    .finish()
-            }
-            NetworkEvent::AddressChange { connection, new_endpoint, old_endpoint } => {
-                f.debug_struct("AddressChange")
-                    .field("connection", connection)
-                    .field("new_endpoint", new_endpoint)
-                    .field("old_endpoint", old_endpoint)
-                    .finish()
-            }
+            NetworkEvent::NewListenerAddress {
+                listener_id,
+                listen_addr,
+            } => f
+                .debug_struct("NewListenerAddress")
+                .field("listener_id", listener_id)
+                .field("listen_addr", listen_addr)
+                .finish(),
+            NetworkEvent::ExpiredListenerAddress {
+                listener_id,
+                listen_addr,
+            } => f
+                .debug_struct("ExpiredListenerAddress")
+                .field("listener_id", listener_id)
+                .field("listen_addr", listen_addr)
+                .finish(),
+            NetworkEvent::ListenerClosed {
+                listener_id,
+                addresses,
+                reason,
+            } => f
+                .debug_struct("ListenerClosed")
+                .field("listener_id", listener_id)
+                .field("addresses", addresses)
+                .field("reason", reason)
+                .finish(),
+            NetworkEvent::ListenerError { listener_id, error } => f
+                .debug_struct("ListenerError")
+                .field("listener_id", listener_id)
+                .field("error", error)
+                .finish(),
+            NetworkEvent::IncomingConnection { connection, .. } => f
+                .debug_struct("IncomingConnection")
+                .field("local_addr", &connection.local_addr)
+                .field("send_back_addr", &connection.send_back_addr)
+                .finish(),
+            NetworkEvent::IncomingConnectionError {
+                local_addr,
+                send_back_addr,
+                error,
+            } => f
+                .debug_struct("IncomingConnectionError")
+                .field("local_addr", local_addr)
+                .field("send_back_addr", send_back_addr)
+                .field("error", error)
+                .finish(),
+            NetworkEvent::ConnectionEstablished { connection, .. } => f
+                .debug_struct("ConnectionEstablished")
+                .field("connection", connection)
+                .finish(),
+            NetworkEvent::ConnectionClosed {
+                id,
+                connected,
+                error,
+                ..
+            } => f
+                .debug_struct("ConnectionClosed")
+                .field("id", id)
+                .field("connected", connected)
+                .field("error", error)
+                .finish(),
+            NetworkEvent::DialError {
+                attempts_remaining,
+                peer_id,
+                multiaddr,
+                error,
+            } => f
+                .debug_struct("DialError")
+                .field("attempts_remaining", attempts_remaining)
+                .field("peer_id", peer_id)
+                .field("multiaddr", multiaddr)
+                .field("error", error)
+                .finish(),
+            NetworkEvent::UnknownPeerDialError {
+                multiaddr, error, ..
+            } => f
+                .debug_struct("UnknownPeerDialError")
+                .field("multiaddr", multiaddr)
+                .field("error", error)
+                .finish(),
+            NetworkEvent::ConnectionEvent { connection, event } => f
+                .debug_struct("ConnectionEvent")
+                .field("connection", connection)
+                .field("event", event)
+                .finish(),
+            NetworkEvent::AddressChange {
+                connection,
+                new_endpoint,
+                old_endpoint,
+            } => f
+                .debug_struct("AddressChange")
+                .field("connection", connection)
+                .field("new_endpoint", new_endpoint)
+                .field("old_endpoint", old_endpoint)
+                .finish(),
         }
     }
 }

core/src/network/peer.rs

@@ -18,35 +18,18 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+use super::{DialError, DialingOpts, Network};
 use crate::{
-    Multiaddr,
-    Transport,
-    StreamMuxer,
     connection::{
-        Connected,
-        ConnectedPoint,
-        ConnectionHandler,
-        Connection,
-        ConnectionId,
-        ConnectionLimit,
-        EstablishedConnection,
-        EstablishedConnectionIter,
-        IntoConnectionHandler,
-        PendingConnection,
-        Substream,
-        handler::THandlerInEvent,
-        pool::Pool,
+        handler::THandlerInEvent, pool::Pool, Connected, ConnectedPoint, Connection,
+        ConnectionHandler, ConnectionId, ConnectionLimit, EstablishedConnection,
+        EstablishedConnectionIter, IntoConnectionHandler, PendingConnection, Substream,
     },
-    PeerId
+    Multiaddr, PeerId, StreamMuxer, Transport,
 };
 use fnv::FnvHashMap;
 use smallvec::SmallVec;
-use std::{
-    collections::hash_map,
-    error,
-    fmt,
-};
-use super::{Network, DialingOpts, DialError};
+use std::{collections::hash_map, error, fmt};
 
 /// The possible representations of a peer in a [`Network`], as
 /// seen by the local node.
@@ -57,7 +40,7 @@ use super::{Network, DialingOpts, DialError};
 pub enum Peer<'a, TTrans, THandler>
 where
     TTrans: Transport,
-    THandler: IntoConnectionHandler
+    THandler: IntoConnectionHandler,
 {
     /// At least one established connection exists to the peer.
     Connected(ConnectedPeer<'a, TTrans, THandler>),
@@ -76,53 +59,33 @@ where
     Local,
 }
 
-impl<'a, TTrans, THandler> fmt::Debug for
-    Peer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> fmt::Debug for Peer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
-            Peer::Connected(p) => {
-                f.debug_struct("Connected")
-                    .field("peer", &p)
-                    .finish()
-            }
-            Peer::Dialing(p) => {
-                f.debug_struct("Dialing")
-                    .field("peer", &p)
-                    .finish()
-            }
-            Peer::Disconnected(p) => {
-                f.debug_struct("Disconnected")
-                    .field("peer", &p)
-                    .finish()
-            }
-            Peer::Local => {
-                f.debug_struct("Local")
-                    .finish()
-            }
+            Peer::Connected(p) => f.debug_struct("Connected").field("peer", &p).finish(),
+            Peer::Dialing(p) => f.debug_struct("Dialing").field("peer", &p).finish(),
+            Peer::Disconnected(p) => f.debug_struct("Disconnected").field("peer", &p).finish(),
+            Peer::Local => f.debug_struct("Local").finish(),
         }
     }
 }
 
-impl<'a, TTrans, THandler>
-    Peer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> Peer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
 {
-    pub(super) fn new(
-        network: &'a mut Network<TTrans, THandler>,
-        peer_id: PeerId
-    ) -> Self {
+    pub(super) fn new(network: &'a mut Network<TTrans, THandler>, peer_id: PeerId) -> Self {
         if peer_id == network.local_peer_id {
             return Peer::Local;
         }
 
         if network.pool.is_connected(&peer_id) {
-            return Self::connected(network, peer_id)
+            return Self::connected(network, peer_id);
         }
 
         if network.dialing.get_mut(&peer_id).is_some() {
@@ -132,31 +95,20 @@ where
         Self::disconnected(network, peer_id)
     }
 
-
-    fn disconnected(
-        network: &'a mut Network<TTrans, THandler>,
-        peer_id: PeerId
-    ) -> Self {
+    fn disconnected(network: &'a mut Network<TTrans, THandler>, peer_id: PeerId) -> Self {
         Peer::Disconnected(DisconnectedPeer { network, peer_id })
     }
 
-    fn connected(
-        network: &'a mut Network<TTrans, THandler>,
-        peer_id: PeerId
-    ) -> Self {
+    fn connected(network: &'a mut Network<TTrans, THandler>, peer_id: PeerId) -> Self {
         Peer::Connected(ConnectedPeer { network, peer_id })
     }
 
-    fn dialing(
-        network: &'a mut Network<TTrans, THandler>,
-        peer_id: PeerId
-    ) -> Self {
+    fn dialing(network: &'a mut Network<TTrans, THandler>, peer_id: PeerId) -> Self {
         Peer::Dialing(DialingPeer { network, peer_id })
     }
 }
 
-impl<'a, TTrans, TMuxer, THandler>
-    Peer<'a, TTrans, THandler>
+impl<'a, TTrans, TMuxer, THandler> Peer<'a, TTrans, THandler>
 where
     TTrans: Transport<Output = (PeerId, TMuxer)> + Clone,
     TTrans::Error: Send + 'static,
@@ -176,7 +128,7 @@ where
             Peer::Connected(..) => true,
             Peer::Dialing(peer) => peer.is_connected(),
             Peer::Disconnected(..) => false,
-            Peer::Local => false
+            Peer::Local => false,
         }
     }
 
@@ -188,7 +140,7 @@ where
             Peer::Dialing(_) => true,
             Peer::Connected(peer) => peer.is_dialing(),
             Peer::Disconnected(..) => false,
-            Peer::Local => false
+            Peer::Local => false,
         }
     }
 
@@ -206,11 +158,12 @@ where
     /// `remaining` addresses are tried in order in subsequent connection
     /// attempts in the context of the same dialing attempt, if the connection
     /// attempt to the first address fails.
-    pub fn dial<I>(self, address: Multiaddr, remaining: I, handler: THandler)
-        -> Result<
-            (ConnectionId, DialingPeer<'a, TTrans, THandler>),
-            DialError
-        >
+    pub fn dial<I>(
+        self,
+        address: Multiaddr,
+        remaining: I,
+        handler: THandler,
+    ) -> Result<(ConnectionId, DialingPeer<'a, TTrans, THandler>), DialError>
     where
         I: IntoIterator<Item = Multiaddr>,
     {
@@ -218,9 +171,12 @@ where
             Peer::Connected(p) => (p.peer_id, p.network),
             Peer::Dialing(p) => (p.peer_id, p.network),
             Peer::Disconnected(p) => (p.peer_id, p.network),
-            Peer::Local => return Err(DialError::ConnectionLimit(ConnectionLimit {
-                current: 0, limit: 0
-            }))
+            Peer::Local => {
+                return Err(DialError::ConnectionLimit(ConnectionLimit {
+                    current: 0,
+                    limit: 0,
+                }))
+            }
         };
 
         let id = network.dial_peer(DialingOpts {
@@ -236,9 +192,7 @@ where
     /// Converts the peer into a `ConnectedPeer`, if an established connection exists.
     ///
     /// Succeeds if the there is at least one established connection to the peer.
-    pub fn into_connected(self) -> Option<
-        ConnectedPeer<'a, TTrans, THandler>
-    > {
+    pub fn into_connected(self) -> Option<ConnectedPeer<'a, TTrans, THandler>> {
         match self {
             Peer::Connected(peer) => Some(peer),
             Peer::Dialing(peer) => peer.into_connected(),
@@ -250,22 +204,18 @@ where
     /// Converts the peer into a `DialingPeer`, if a dialing attempt exists.
     ///
     /// Succeeds if the there is at least one pending outgoing connection to the peer.
-    pub fn into_dialing(self) -> Option<
-        DialingPeer<'a, TTrans, THandler>
-    > {
+    pub fn into_dialing(self) -> Option<DialingPeer<'a, TTrans, THandler>> {
         match self {
             Peer::Dialing(peer) => Some(peer),
             Peer::Connected(peer) => peer.into_dialing(),
             Peer::Disconnected(..) => None,
-            Peer::Local => None
+            Peer::Local => None,
         }
     }
 
     /// Converts the peer into a `DisconnectedPeer`, if neither an established connection
     /// nor a dialing attempt exists.
-    pub fn into_disconnected(self) -> Option<
-        DisconnectedPeer<'a, TTrans, THandler>
-    > {
+    pub fn into_disconnected(self) -> Option<DisconnectedPeer<'a, TTrans, THandler>> {
         match self {
             Peer::Disconnected(peer) => Some(peer),
             _ => None,
@@ -285,8 +235,7 @@ where
     peer_id: PeerId,
 }
 
-impl<'a, TTrans, THandler>
-    ConnectedPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> ConnectedPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -301,9 +250,10 @@ where
     }
 
     /// Obtains an established connection to the peer by ID.
-    pub fn connection(&mut self, id: ConnectionId)
-        -> Option<EstablishedConnection<THandlerInEvent<THandler>>>
-    {
+    pub fn connection(
+        &mut self,
+        id: ConnectionId,
+    ) -> Option<EstablishedConnection<THandlerInEvent<THandler>>> {
         self.network.pool.get_established(id)
     }
 
@@ -321,47 +271,43 @@ where
 
     /// Converts this peer into a [`DialingPeer`], if there is an ongoing
     /// dialing attempt, `None` otherwise.
-    pub fn into_dialing(self) -> Option<
-        DialingPeer<'a, TTrans, THandler>
-    > {
+    pub fn into_dialing(self) -> Option<DialingPeer<'a, TTrans, THandler>> {
         if self.network.dialing.contains_key(&self.peer_id) {
-            Some(DialingPeer { network: self.network, peer_id: self.peer_id })
+            Some(DialingPeer {
+                network: self.network,
+                peer_id: self.peer_id,
+            })
         } else {
             None
         }
     }
 
     /// Gets an iterator over all established connections to the peer.
-    pub fn connections(&mut self) ->
-        EstablishedConnectionIter<
-            impl Iterator<Item = ConnectionId>,
-            THandler,
-            TTrans::Error,
-        >
+    pub fn connections(
+        &mut self,
+    ) -> EstablishedConnectionIter<impl Iterator<Item = ConnectionId>, THandler, TTrans::Error>
     {
         self.network.pool.iter_peer_established(&self.peer_id)
     }
 
     /// Obtains some established connection to the peer.
-    pub fn some_connection(&mut self)
-        -> EstablishedConnection<THandlerInEvent<THandler>>
-    {
+    pub fn some_connection(&mut self) -> EstablishedConnection<THandlerInEvent<THandler>> {
         self.connections()
             .into_first()
             .expect("By `Peer::new` and the definition of `ConnectedPeer`.")
     }
 
     /// Disconnects from the peer, closing all connections.
-    pub fn disconnect(self)
-        -> DisconnectedPeer<'a, TTrans, THandler>
-    {
+    pub fn disconnect(self) -> DisconnectedPeer<'a, TTrans, THandler> {
         self.network.disconnect(&self.peer_id);
-        DisconnectedPeer { network: self.network, peer_id: self.peer_id }
+        DisconnectedPeer {
+            network: self.network,
+            peer_id: self.peer_id,
+        }
     }
 }
 
-impl<'a, TTrans, THandler> fmt::Debug for
-    ConnectedPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> fmt::Debug for ConnectedPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -369,7 +315,10 @@ where
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         f.debug_struct("ConnectedPeer")
             .field("peer_id", &self.peer_id)
-            .field("established", &self.network.pool.iter_peer_established_info(&self.peer_id))
+            .field(
+                "established",
+                &self.network.pool.iter_peer_established_info(&self.peer_id),
+            )
             .field("attempts", &self.network.dialing.get(&self.peer_id))
             .finish()
     }
@@ -387,8 +336,7 @@ where
     peer_id: PeerId,
 }
 
-impl<'a, TTrans, THandler>
-    DialingPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> DialingPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -404,11 +352,12 @@ where
 
     /// Disconnects from this peer, closing all established connections and
     /// aborting all dialing attempts.
-    pub fn disconnect(self)
-        -> DisconnectedPeer<'a, TTrans, THandler>
-    {
+    pub fn disconnect(self) -> DisconnectedPeer<'a, TTrans, THandler> {
         self.network.disconnect(&self.peer_id);
-        DisconnectedPeer { network: self.network, peer_id: self.peer_id }
+        DisconnectedPeer {
+            network: self.network,
+            peer_id: self.peer_id,
+        }
     }
 
     /// Checks whether there is an established connection to the peer.
@@ -419,11 +368,12 @@ where
     }
 
     /// Converts the peer into a `ConnectedPeer`, if an established connection exists.
-    pub fn into_connected(self)
-        -> Option<ConnectedPeer<'a, TTrans, THandler>>
-    {
+    pub fn into_connected(self) -> Option<ConnectedPeer<'a, TTrans, THandler>> {
         if self.is_connected() {
-            Some(ConnectedPeer { peer_id: self.peer_id, network: self.network })
+            Some(ConnectedPeer {
+                peer_id: self.peer_id,
+                network: self.network,
+            })
         } else {
             None
         }
@@ -431,13 +381,18 @@ where
 
     /// Obtains a dialing attempt to the peer by connection ID of
     /// the current connection attempt.
-    pub fn attempt(&mut self, id: ConnectionId)
-        -> Option<DialingAttempt<'_, THandlerInEvent<THandler>>>
-    {
+    pub fn attempt(
+        &mut self,
+        id: ConnectionId,
+    ) -> Option<DialingAttempt<'_, THandlerInEvent<THandler>>> {
         if let hash_map::Entry::Occupied(attempts) = self.network.dialing.entry(self.peer_id) {
             if let Some(pos) = attempts.get().iter().position(|s| s.current.0 == id) {
                 if let Some(inner) = self.network.pool.get_outgoing(id) {
-                    return Some(DialingAttempt { pos, inner, attempts })
+                    return Some(DialingAttempt {
+                        pos,
+                        inner,
+                        attempts,
+                    });
                 }
             }
         }
@@ -445,25 +400,25 @@ where
     }
 
     /// Gets an iterator over all dialing (i.e. pending outgoing) connections to the peer.
-    pub fn attempts(&mut self) -> DialingAttemptIter<'_, THandler, TTrans::Error>
-    {
-        DialingAttemptIter::new(&self.peer_id, &mut self.network.pool, &mut self.network.dialing)
+    pub fn attempts(&mut self) -> DialingAttemptIter<'_, THandler, TTrans::Error> {
+        DialingAttemptIter::new(
+            &self.peer_id,
+            &mut self.network.pool,
+            &mut self.network.dialing,
+        )
     }
 
     /// Obtains some dialing connection to the peer.
     ///
     /// At least one dialing connection is guaranteed to exist on a `DialingPeer`.
-    pub fn some_attempt(&mut self)
-        -> DialingAttempt<'_, THandlerInEvent<THandler>>
-    {
+    pub fn some_attempt(&mut self) -> DialingAttempt<'_, THandlerInEvent<THandler>> {
         self.attempts()
             .into_first()
             .expect("By `Peer::new` and the definition of `DialingPeer`.")
     }
 }
 
-impl<'a, TTrans, THandler> fmt::Debug for
-    DialingPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> fmt::Debug for DialingPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -471,7 +426,10 @@ where
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         f.debug_struct("DialingPeer")
             .field("peer_id", &self.peer_id)
-            .field("established", &self.network.pool.iter_peer_established_info(&self.peer_id))
+            .field(
+                "established",
+                &self.network.pool.iter_peer_established_info(&self.peer_id),
+            )
             .field("attempts", &self.network.dialing.get(&self.peer_id))
             .finish()
     }
@@ -489,8 +447,7 @@ where
     network: &'a mut Network<TTrans, THandler>,
 }
 
-impl<'a, TTrans, THandler> fmt::Debug for
-    DisconnectedPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> fmt::Debug for DisconnectedPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -502,8 +459,7 @@ where
     }
 }
 
-impl<'a, TTrans, THandler>
-    DisconnectedPeer<'a, TTrans, THandler>
+impl<'a, TTrans, THandler> DisconnectedPeer<'a, TTrans, THandler>
 where
     TTrans: Transport,
     THandler: IntoConnectionHandler,
@@ -529,10 +485,8 @@ where
         self,
         connected: Connected,
         connection: Connection<TMuxer, THandler::Handler>,
-    ) -> Result<
-        ConnectedPeer<'a, TTrans, THandler>,
-        ConnectionLimit
-    > where
+    ) -> Result<ConnectedPeer<'a, TTrans, THandler>, ConnectionLimit>
+    where
         THandler: Send + 'static,
         TTrans::Error: Send + 'static,
         THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>> + Send,
@@ -542,10 +496,15 @@ where
         TMuxer::OutboundSubstream: Send,
     {
         if connected.peer_id != self.peer_id {
-            panic!("Invalid peer ID given: {:?}. Expected: {:?}", connected.peer_id, self.peer_id)
+            panic!(
+                "Invalid peer ID given: {:?}. Expected: {:?}",
+                connected.peer_id, self.peer_id
+            )
         }
 
-        self.network.pool.add(connection, connected)
+        self.network
+            .pool
+            .add(connection, connected)
             .map(move |_id| ConnectedPeer {
                 network: self.network,
                 peer_id: self.peer_id,
@@ -575,9 +534,7 @@ pub struct DialingAttempt<'a, TInEvent> {
     pos: usize,
 }
 
-impl<'a, TInEvent>
-    DialingAttempt<'a, TInEvent>
-{
+impl<'a, TInEvent> DialingAttempt<'a, TInEvent> {
     /// Returns the ID of the current connection attempt.
     pub fn id(&self) -> ConnectionId {
         self.inner.id()
@@ -592,7 +549,7 @@ impl<'a, TInEvent>
     pub fn address(&self) -> &Multiaddr {
         match self.inner.endpoint() {
             ConnectedPoint::Dialer { address } => address,
-            ConnectedPoint::Listener { .. } => unreachable!("by definition of a `DialingAttempt`.")
+            ConnectedPoint::Listener { .. } => unreachable!("by definition of a `DialingAttempt`."),
         }
     }
 
@@ -640,16 +597,20 @@ pub struct DialingAttemptIter<'a, THandler: IntoConnectionHandler, TTransErr> {
 // Note: Ideally this would be an implementation of `Iterator`, but that
 // requires GATs (cf. https://github.com/rust-lang/rust/issues/44265) and
 // a different definition of `Iterator`.
-impl<'a, THandler: IntoConnectionHandler, TTransErr>
-    DialingAttemptIter<'a, THandler, TTransErr>
-{
+impl<'a, THandler: IntoConnectionHandler, TTransErr> DialingAttemptIter<'a, THandler, TTransErr> {
     fn new(
         peer_id: &'a PeerId,
         pool: &'a mut Pool<THandler, TTransErr>,
         dialing: &'a mut FnvHashMap<PeerId, SmallVec<[DialingState; 10]>>,
     ) -> Self {
         let end = dialing.get(peer_id).map_or(0, |conns| conns.len());
-        Self { pos: 0, end, pool, dialing, peer_id }
+        Self {
+            pos: 0,
+            end,
+            pool,
+            dialing,
+            peer_id,
+        }
     }
 
     /// Obtains the next dialing connection, if any.
@@ -658,22 +619,29 @@ impl<'a, THandler: IntoConnectionHandler, TTransErr>
         // If the number of elements reduced, the current `DialingAttempt` has been
         // aborted and iteration needs to continue from the previous position to
         // account for the removed element.
-        let end = self.dialing.get(self.peer_id).map_or(0, |conns| conns.len());
+        let end = self
+            .dialing
+            .get(self.peer_id)
+            .map_or(0, |conns| conns.len());
         if self.end > end {
             self.end = end;
             self.pos -= 1;
         }
 
         if self.pos == self.end {
-            return None
+            return None;
         }
 
         if let hash_map::Entry::Occupied(attempts) = self.dialing.entry(*self.peer_id) {
             let id = attempts.get()[self.pos].current.0;
             if let Some(inner) = self.pool.get_outgoing(id) {
-                let conn = DialingAttempt { pos: self.pos, inner, attempts };
+                let conn = DialingAttempt {
+                    pos: self.pos,
+                    inner,
+                    attempts,
+                };
                 self.pos += 1;
-                return Some(conn)
+                return Some(conn);
             }
         }
 
@@ -681,18 +649,22 @@ impl<'a, THandler: IntoConnectionHandler, TTransErr>
     }
 
     /// Returns the first connection, if any, consuming the iterator.
-    pub fn into_first<'b>(self)
-        -> Option<DialingAttempt<'b, THandlerInEvent<THandler>>>
-    where 'a: 'b
+    pub fn into_first<'b>(self) -> Option<DialingAttempt<'b, THandlerInEvent<THandler>>>
+    where
+        'a: 'b,
     {
         if self.pos == self.end {
-            return None
+            return None;
         }
 
         if let hash_map::Entry::Occupied(attempts) = self.dialing.entry(*self.peer_id) {
             let id = attempts.get()[self.pos].current.0;
             if let Some(inner) = self.pool.get_outgoing(id) {
-                return Some(DialingAttempt { pos: self.pos, inner, attempts })
+                return Some(DialingAttempt {
+                    pos: self.pos,
+                    inner,
+                    attempts,
+                });
             }
         }