refactor(swarm)!: refactor ListenUpgradeError and DialUpgradeError

protocols/dcutr/CHANGELOG.md

@@ -2,7 +2,8 @@
 
 - Update to `libp2p-core` `v0.39.0`.
 
-- Update to `libp2p-swarm` `v0.42.0`.
+- Update to `libp2p-swarm` `v0.42.0`. Update to the `libp2p_swarm::handler::ConnectionEvent` `DialTimeout` introduction and consequential changes.
+  With that introduce `Event::DirectConnectionUpgradeTimedout`. See [PR 3307].
 
 - Declare `InboundUpgradeError` and `OutboundUpgradeError` as type aliases instead of renames.
   This is a workaround for a missing feature in `cargo semver-checks`. See [PR 3213].
@@ -15,6 +16,7 @@
 [PR 3153]: https://github.com/libp2p/rust-libp2p/pull/3153
 [issue 2217]: https://github.com/libp2p/rust-libp2p/issues/2217
 [PR 3214]: https://github.com/libp2p/rust-libp2p/pull/3214
+[PR 3307]: https://github.com/libp2p/rust-libp2p/pull/3307
 
 # 0.8.0
 

protocols/dcutr/src/behaviour_impl.rs

@@ -25,12 +25,13 @@ use crate::protocol;
 use either::Either;
 use libp2p_core::connection::{ConnectedPoint, ConnectionId};
 use libp2p_core::multiaddr::Protocol;
+use libp2p_core::UpgradeError;
 use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
 use libp2p_swarm::dial_opts::{self, DialOpts};
 use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerUpgrErr, ExternalAddresses, IntoConnectionHandler,
-    NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
+    ConnectionHandler, ExternalAddresses, IntoConnectionHandler, NetworkBehaviour,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::task::{Context, Poll};
@@ -56,14 +57,17 @@ pub enum Event {
         remote_peer_id: PeerId,
         error: Error,
     },
+    DirectConnectionUpgradeTimedout {
+        remote_peer_id: PeerId,
+    },
 }
 
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Failed to dial peer.")]
     Dial,
     #[error("Failed to establish substream: {0}.")]
-    Handler(ConnectionHandlerUpgrErr<void::Void>),
+    Handler(UpgradeError<void::Void>),
 }
 
 pub struct Behaviour {
@@ -241,6 +245,14 @@ impl NetworkBehaviour for Behaviour {
                     .into(),
                 );
             }
+            Either::Left(handler::relayed::Event::InboundNegotiationTimedout) => {
+                self.queued_actions.push_back(
+                    NetworkBehaviourAction::GenerateEvent(Event::DirectConnectionUpgradeTimedout {
+                        remote_peer_id: event_source,
+                    })
+                    .into(),
+                );
+            }
             Either::Left(handler::relayed::Event::InboundConnectNegotiated(remote_addrs)) => {
                 self.queued_actions.push_back(
                     NetworkBehaviourAction::Dial {

protocols/dcutr/src/handler/direct.rs

@@ -22,11 +22,9 @@
 
 use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::DeniedUpgrade;
+use libp2p_core::UpgradeError;
 use libp2p_swarm::handler::ConnectionEvent;
-use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, KeepAlive,
-    SubstreamProtocol,
-};
+use libp2p_swarm::{ConnectionHandler, ConnectionHandlerEvent, KeepAlive, SubstreamProtocol};
 use std::task::{Context, Poll};
 use void::Void;
 
@@ -52,7 +50,7 @@ impl Handler {
 impl ConnectionHandler for Handler {
     type InEvent = void::Void;
     type OutEvent = Event;
-    type Error = ConnectionHandlerUpgrErr<std::io::Error>;
+    type Error = UpgradeError<std::io::Error>;
     type InboundProtocol = DeniedUpgrade;
     type OutboundProtocol = DeniedUpgrade;
     type OutboundOpenInfo = Void;
@@ -103,6 +101,7 @@ impl ConnectionHandler for Handler {
             ConnectionEvent::FullyNegotiatedInbound(_)
             | ConnectionEvent::FullyNegotiatedOutbound(_)
             | ConnectionEvent::DialUpgradeError(_)
+            | ConnectionEvent::DialTimeout(_)
             | ConnectionEvent::ListenUpgradeError(_)
             | ConnectionEvent::AddressChange(_) => {}
         }

protocols/dcutr/src/handler/relayed.rs

@@ -31,10 +31,7 @@ use libp2p_swarm::handler::{
     ConnectionEvent, DialUpgradeError, FullyNegotiatedInbound, FullyNegotiatedOutbound,
     ListenUpgradeError,
 };
-use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, KeepAlive,
-    SubstreamProtocol,
-};
+use libp2p_swarm::{ConnectionHandler, ConnectionHandlerEvent, KeepAlive, SubstreamProtocol};
 use std::collections::VecDeque;
 use std::fmt;
 use std::task::{Context, Poll};
@@ -83,11 +80,12 @@ pub enum Event {
         remote_addr: Multiaddr,
     },
     InboundNegotiationFailed {
-        error: ConnectionHandlerUpgrErr<void::Void>,
+        error: UpgradeError<void::Void>,
     },
+    InboundNegotiationTimedout,
     InboundConnectNegotiated(Vec<Multiaddr>),
     OutboundNegotiationFailed {
-        error: ConnectionHandlerUpgrErr<void::Void>,
+        error: UpgradeError<void::Void>,
     },
     OutboundConnectNegotiated {
         remote_addrs: Vec<Multiaddr>,
@@ -109,6 +107,9 @@ impl fmt::Debug for Event {
                 .debug_struct("Event::InboundNegotiationFailed")
                 .field("error", error)
                 .finish(),
+            Event::InboundNegotiationTimedout => {
+                f.debug_struct("Event::InboundNegotiationTimedout").finish()
+            }
             Event::InboundConnectNegotiated(addrs) => f
                 .debug_tuple("Event::InboundConnectNegotiated")
                 .field(addrs)
@@ -133,7 +134,7 @@ pub struct Handler {
     endpoint: ConnectedPoint,
     /// A pending fatal error that results in the connection being closed.
     pending_error: Option<
-        ConnectionHandlerUpgrErr<
+        UpgradeError<
             EitherError<protocol::inbound::UpgradeError, protocol::outbound::UpgradeError>,
         >,
     >,
@@ -220,34 +221,23 @@ impl Handler {
         >,
     ) {
         match error {
-            ConnectionHandlerUpgrErr::Timeout => {
-                self.queued_events.push_back(ConnectionHandlerEvent::Custom(
-                    Event::InboundNegotiationFailed {
-                        error: ConnectionHandlerUpgrErr::Timeout,
-                    },
-                ));
-            }
-            ConnectionHandlerUpgrErr::Upgrade(UpgradeError::Select(NegotiationError::Failed)) => {
+            UpgradeError::Select(NegotiationError::Failed) => {
                 // The remote merely doesn't support the DCUtR protocol.
                 // This is no reason to close the connection, which may
                 // successfully communicate with other protocols already.
                 self.keep_alive = KeepAlive::No;
                 self.queued_events.push_back(ConnectionHandlerEvent::Custom(
                     Event::InboundNegotiationFailed {
-                        error: ConnectionHandlerUpgrErr::Upgrade(UpgradeError::Select(
-                            NegotiationError::Failed,
-                        )),
+                        error: UpgradeError::Select(NegotiationError::Failed),
                     },
                 ));
             }
             _ => {
                 // Anything else is considered a fatal error or misbehaviour of
                 // the remote peer and results in closing the connection.
-                self.pending_error = Some(error.map_upgrade_err(|e| {
-                    e.map_err(|e| match e {
-                        EitherError::A(e) => EitherError::A(e),
-                        EitherError::B(v) => void::unreachable(v),
-                    })
+                self.pending_error = Some(error.map_err(|e| match e {
+                    EitherError::A(e) => EitherError::A(e),
+                    EitherError::B(v) => void::unreachable(v),
                 }));
             }
         }
@@ -263,29 +253,20 @@ impl Handler {
         self.keep_alive = KeepAlive::No;
 
         match error {
-            ConnectionHandlerUpgrErr::Timeout => {
-                self.queued_events.push_back(ConnectionHandlerEvent::Custom(
-                    Event::OutboundNegotiationFailed {
-                        error: ConnectionHandlerUpgrErr::Timeout,
-                    },
-                ));
-            }
-            ConnectionHandlerUpgrErr::Upgrade(UpgradeError::Select(NegotiationError::Failed)) => {
+            UpgradeError::Select(NegotiationError::Failed) => {
                 // The remote merely doesn't support the DCUtR protocol.
                 // This is no reason to close the connection, which may
                 // successfully communicate with other protocols already.
                 self.queued_events.push_back(ConnectionHandlerEvent::Custom(
                     Event::OutboundNegotiationFailed {
-                        error: ConnectionHandlerUpgrErr::Upgrade(UpgradeError::Select(
-                            NegotiationError::Failed,
-                        )),
+                        error: UpgradeError::Select(NegotiationError::Failed),
                     },
                 ));
             }
             _ => {
                 // Anything else is considered a fatal error or misbehaviour of
                 // the remote peer and results in closing the connection.
-                self.pending_error = Some(error.map_upgrade_err(|e| e.map_err(EitherError::B)));
+                self.pending_error = Some(error.map_err(EitherError::B));
             }
         }
     }
@@ -294,7 +275,7 @@ impl Handler {
 impl ConnectionHandler for Handler {
     type InEvent = Command;
     type OutEvent = Event;
-    type Error = ConnectionHandlerUpgrErr<
+    type Error = UpgradeError<
         EitherError<protocol::inbound::UpgradeError, protocol::outbound::UpgradeError>,
     >;
     type InboundProtocol = upgrade::EitherUpgrade<protocol::inbound::Upgrade, DeniedUpgrade>;
@@ -385,9 +366,9 @@ impl ConnectionHandler for Handler {
                     ));
                 }
                 Err(e) => {
-                    return Poll::Ready(ConnectionHandlerEvent::Close(
-                        ConnectionHandlerUpgrErr::Upgrade(UpgradeError::Apply(EitherError::A(e))),
-                    ))
+                    return Poll::Ready(ConnectionHandlerEvent::Close(UpgradeError::Apply(
+                        EitherError::A(e),
+                    )))
                 }
             }
         }
@@ -417,6 +398,11 @@ impl ConnectionHandler for Handler {
             ConnectionEvent::DialUpgradeError(dial_upgrade_error) => {
                 self.on_dial_upgrade_error(dial_upgrade_error)
             }
+            ConnectionEvent::DialTimeout(_) => {
+                self.queued_events.push_back(ConnectionHandlerEvent::Custom(
+                    Event::InboundNegotiationTimedout,
+                ));
+            }
             ConnectionEvent::AddressChange(_) => {}
         }
     }