feat(swarm)!: Allow NetworkBehaviours to manage incoming connections

protocols/autonat/src/behaviour.rs

@@ -37,9 +37,7 @@ use libp2p_request_response::{
     RequestResponseConfig, RequestResponseEvent, RequestResponseMessage, ResponseChannel,
 };
 use libp2p_swarm::behaviour::THandlerInEvent;
-use libp2p_swarm::{
-    DialError, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
-};
+use libp2p_swarm::{DialError, NetworkBehaviour, NetworkBehaviourAction, PollParameters};
 use std::{
     collections::{HashMap, VecDeque},
     iter,
@@ -304,7 +302,6 @@ impl Behaviour {
 impl NetworkBehaviour for Behaviour {
     type ConnectionHandler = <RequestResponse<AutoNatCodec> as NetworkBehaviour>::ConnectionHandler;
     type OutEvent = Event;
-    type DialPayload = ();
 
     fn inject_connection_established(
         &mut self,
@@ -358,7 +355,7 @@ impl NetworkBehaviour for Behaviour {
         peer: &PeerId,
         conn: &ConnectionId,
         endpoint: &ConnectedPoint,
-        handler: <Self::ConnectionHandler as IntoConnectionHandler>::Handler,
+        handler: Self::ConnectionHandler,
         remaining_established: usize,
     ) {
         self.inner
@@ -371,14 +368,9 @@ impl NetworkBehaviour for Behaviour {
         }
     }
 
-    fn inject_dial_failure(
-        &mut self,
-        peer: Option<PeerId>,
-        initial_event: Option<Self::DialPayload>,
-        error: &DialError,
-    ) {
-        self.inner.inject_dial_failure(peer, initial_event, error);
-        if let Some(event) = self.as_server().on_outbound_dial_error(peer, error) {
+    fn inject_dial_failure(&mut self, _peer_id: Option<PeerId>, _error: &DialError) {
+        self.inner.inject_dial_failure(_peer_id, _error);
+        if let Some(event) = self.as_server().on_outbound_dial_error(_peer_id, _error) {
             self.pending_out_events
                 .push_back(Event::InboundProbe(event));
         }
@@ -472,8 +464,12 @@ impl NetworkBehaviour for Behaviour {
         }
     }
 
-    fn new_handler(&mut self) -> Self::ConnectionHandler {
-        self.inner.new_handler()
+    fn new_handler(
+        &mut self,
+        peer: &PeerId,
+        connected_point: &ConnectedPoint,
+    ) -> Self::ConnectionHandler {
+        self.inner.new_handler(peer, connected_point)
     }
 
     fn addresses_of_peer(&mut self, peer: &PeerId) -> Vec<Multiaddr> {

protocols/autonat/src/behaviour/as_server.rs

@@ -137,7 +137,6 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                                 .override_dial_concurrency_factor(NonZeroU8::new(1).expect("1 > 0"))
                                 .addresses(addrs)
                                 .build(),
-                            dial_payload: (),
                         });
                     }
                     Err((status_text, error)) => {

protocols/dcutr/src/behaviour.rs

@@ -29,8 +29,8 @@ use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::behaviour::THandlerInEvent;
 use libp2p_swarm::dial_opts::{self, DialOpts};
 use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerUpgrErr, DialError, IntoConnectionHandler,
-    NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
+    dummy, ConnectionHandler, ConnectionHandlerUpgrErr, DialError, NetworkBehaviour,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::task::{Context, Poll};
@@ -75,6 +75,9 @@ pub struct Behaviour {
     direct_connections: HashMap<PeerId, HashSet<ConnectionId>>,
 }
 
+type Handler =
+    Either<handler::relayed::Handler, Either<handler::direct::Handler, dummy::ConnectionHandler>>;
+
 impl Behaviour {
     pub fn new() -> Self {
         Behaviour {
@@ -85,26 +88,17 @@ impl Behaviour {
 }
 
 impl NetworkBehaviour for Behaviour {
-    type ConnectionHandler = handler::Prototype;
+    type ConnectionHandler = Handler;
     type OutEvent = Event;
-    type DialPayload = handler::Prototype;
-
-    fn new_handler(&mut self) -> Self::ConnectionHandler {
-        handler::Prototype::UnknownConnection
-    }
 
-    fn new_inbound_handler(&mut self) -> Self::ConnectionHandler {
-        handler::Prototype::UnknownConnection
-    }
-
-    fn new_outbound_handler(
+    fn new_handler(
         &mut self,
-        dial_payload: Option<Self::DialPayload>,
+        peer: &PeerId,
+        connected_point: &ConnectedPoint,
     ) -> Self::ConnectionHandler {
-        match dial_payload {
-            Some(prototype) => prototype,
-            None => handler::Prototype::UnknownConnection,
-        }
+        // handler::Prototype::UnknownConnection
+
+        todo!()
     }
 
     fn addresses_of_peer(&mut self, _peer_id: &PeerId) -> Vec<Multiaddr> {
@@ -156,50 +150,46 @@ impl NetworkBehaviour for Behaviour {
         }
     }
 
-    fn inject_dial_failure(
-        &mut self,
-        peer_id: Option<PeerId>,
-        dial_payload: Option<Self::DialPayload>,
-        _error: &DialError,
-    ) {
-        if let Some(handler::Prototype::DirectConnection {
-            relayed_connection_id,
-            role: handler::Role::Initiator { attempt },
-        }) = dial_payload
-        {
-            let peer_id = peer_id.expect("Peer of `Prototype::DirectConnection` is always known.");
-            if attempt < MAX_NUMBER_OF_UPGRADE_ATTEMPTS {
-                self.queued_actions.push_back(ActionBuilder::Connect {
-                    peer_id,
-                    handler: NotifyHandler::One(relayed_connection_id),
-                    attempt: attempt + 1,
-                });
-            } else {
-                self.queued_actions.extend([
-                    NetworkBehaviourAction::NotifyHandler {
-                        peer_id,
-                        handler: NotifyHandler::One(relayed_connection_id),
-                        event: Either::Left(
-                            handler::relayed::Command::UpgradeFinishedDontKeepAlive,
-                        ),
-                    }
-                    .into(),
-                    NetworkBehaviourAction::GenerateEvent(Event::DirectConnectionUpgradeFailed {
-                        remote_peer_id: peer_id,
-                        error: UpgradeError::Dial,
-                    })
-                    .into(),
-                ]);
-            }
-        }
+    fn inject_dial_failure(&mut self, _peer_id: Option<PeerId>, _error: &DialError) {
+        // TODO: Track state in behaviour
+        // if let Some(handler::Prototype::DirectConnection {
+        //     relayed_connection_id,
+        //     role: handler::Role::Initiator { attempt },
+        // }) = dial_payload
+        // {
+        //     let peer_id = _peer_id.expect("Peer of `Prototype::DirectConnection` is always known.");
+        //     if attempt < MAX_NUMBER_OF_UPGRADE_ATTEMPTS {
+        //         self.queued_actions.push_back(ActionBuilder::Connect {
+        //             peer_id,
+        //             handler: NotifyHandler::One(relayed_connection_id),
+        //             attempt: attempt + 1,
+        //         });
+        //     } else {
+        //         self.queued_actions.extend([
+        //             NetworkBehaviourAction::NotifyHandler {
+        //                 peer_id,
+        //                 handler: NotifyHandler::One(relayed_connection_id),
+        //                 event: Either::Left(
+        //                     handler::relayed::Command::UpgradeFinishedDontKeepAlive,
+        //                 ),
+        //             }
+        //             .into(),
+        //             NetworkBehaviourAction::GenerateEvent(Event::DirectConnectionUpgradeFailed {
+        //                 remote_peer_id: peer_id,
+        //                 error: UpgradeError::Dial,
+        //             })
+        //             .into(),
+        //         ]);
+        //     }
+        // }
     }
 
     fn inject_connection_closed(
         &mut self,
         peer_id: &PeerId,
         connection_id: &ConnectionId,
         connected_point: &ConnectedPoint,
-        _handler: <<Self as NetworkBehaviour>::ConnectionHandler as IntoConnectionHandler>::Handler,
+        _handler: Self::ConnectionHandler,
         _remaining_established: usize,
     ) {
         if !connected_point.is_relayed() {
@@ -221,7 +211,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         event_source: PeerId,
         connection: ConnectionId,
-        handler_event: <<Self::ConnectionHandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutEvent,
+        handler_event: <Self::ConnectionHandler as ConnectionHandler>::OutEvent,
     ) {
         match handler_event {
             Either::Left(handler::relayed::Event::InboundConnectRequest {
@@ -259,10 +249,10 @@ impl NetworkBehaviour for Behaviour {
                             .addresses(remote_addrs)
                             .condition(dial_opts::PeerCondition::Always)
                             .build(),
-                        dial_payload: handler::Prototype::DirectConnection {
-                            relayed_connection_id: connection,
-                            role: handler::Role::Listener,
-                        },
+                        // dial_payload: handler::Prototype::DirectConnection {
+                        //     relayed_connection_id: connection,
+                        //     role: handler::Role::Listener,
+                        // },
                     }
                     .into(),
                 );
@@ -287,10 +277,10 @@ impl NetworkBehaviour for Behaviour {
                             .addresses(remote_addrs)
                             .override_role()
                             .build(),
-                        dial_payload: handler::Prototype::DirectConnection {
-                            relayed_connection_id: connection,
-                            role: handler::Role::Initiator { attempt },
-                        },
+                        // dial_payload: handler::Prototype::DirectConnection {
+                        //     relayed_connection_id: connection,
+                        //     role: handler::Role::Initiator { attempt },
+                        // },
                     }
                     .into(),
                 );
@@ -325,13 +315,8 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         _cx: &mut Context<'_>,
         poll_parameters: &mut impl PollParameters,
-    ) -> Poll<
-        NetworkBehaviourAction<
-            Self::OutEvent,
-            THandlerInEvent<Self::ConnectionHandler>,
-            handler::Prototype,
-        >,
-    > {
+    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, THandlerInEvent<Self::ConnectionHandler>>>
+    {
         if let Some(action) = self.queued_actions.pop_front() {
             return Poll::Ready(action.build(poll_parameters));
         }
@@ -343,7 +328,7 @@ impl NetworkBehaviour for Behaviour {
 /// A [`NetworkBehaviourAction`], either complete, or still requiring data from [`PollParameters`]
 /// before being returned in [`Behaviour::poll`].
 enum ActionBuilder {
-    Done(NetworkBehaviourAction<Event, THandlerInEvent<handler::Prototype>, handler::Prototype>),
+    Done(NetworkBehaviourAction<Event, THandlerInEvent<Handler>>),
     Connect {
         attempt: u8,
         handler: NotifyHandler,
@@ -356,16 +341,8 @@ enum ActionBuilder {
     },
 }
 
-impl From<NetworkBehaviourAction<Event, THandlerInEvent<handler::Prototype>, handler::Prototype>>
-    for ActionBuilder
-{
-    fn from(
-        action: NetworkBehaviourAction<
-            Event,
-            THandlerInEvent<handler::Prototype>,
-            handler::Prototype,
-        >,
-    ) -> Self {
+impl From<NetworkBehaviourAction<Event, THandlerInEvent<Handler>>> for ActionBuilder {
+    fn from(action: NetworkBehaviourAction<Event, THandlerInEvent<Handler>>) -> Self {
         Self::Done(action)
     }
 }
@@ -374,8 +351,7 @@ impl ActionBuilder {
     fn build(
         self,
         poll_parameters: &mut impl PollParameters,
-    ) -> NetworkBehaviourAction<Event, THandlerInEvent<handler::Prototype>, handler::Prototype>
-    {
+    ) -> NetworkBehaviourAction<Event, THandlerInEvent<Handler>> {
         let obs_addrs = || {
             poll_parameters
                 .external_addresses()

protocols/dcutr/src/handler.rs

@@ -25,7 +25,7 @@ use libp2p_core::upgrade::{self, DeniedUpgrade};
 use libp2p_core::{ConnectedPoint, PeerId};
 use libp2p_swarm::dummy;
 use libp2p_swarm::handler::SendWrapper;
-use libp2p_swarm::{ConnectionHandler, IntoConnectionHandler};
+use libp2p_swarm::ConnectionHandler;
 
 pub mod direct;
 pub mod relayed;
@@ -43,39 +43,40 @@ pub enum Role {
     Listener,
 }
 
-impl IntoConnectionHandler for Prototype {
-    type Handler = Either<relayed::Handler, Either<direct::Handler, dummy::ConnectionHandler>>;
-
-    fn into_handler(self, _remote_peer_id: &PeerId, endpoint: &ConnectedPoint) -> Self::Handler {
-        match self {
-            Self::UnknownConnection => {
-                if endpoint.is_relayed() {
-                    Either::Left(relayed::Handler::new(endpoint.clone()))
-                } else {
-                    Either::Right(Either::Right(dummy::ConnectionHandler))
-                }
-            }
-            Self::DirectConnection {
-                relayed_connection_id,
-                ..
-            } => {
-                assert!(
-                    !endpoint.is_relayed(),
-                    "`Prototype::DirectConnection` is never created for relayed connection."
-                );
-                Either::Right(Either::Left(direct::Handler::new(relayed_connection_id)))
-            }
-        }
-    }
-
-    fn inbound_protocol(&self) -> <Self::Handler as ConnectionHandler>::InboundProtocol {
-        match self {
-            Prototype::UnknownConnection => upgrade::EitherUpgrade::A(SendWrapper(
-                upgrade::EitherUpgrade::A(protocol::inbound::Upgrade {}),
-            )),
-            Prototype::DirectConnection { .. } => {
-                upgrade::EitherUpgrade::A(SendWrapper(upgrade::EitherUpgrade::B(DeniedUpgrade)))
-            }
-        }
-    }
-}
+// TODO
+// impl IntoConnectionHandler for Prototype {
+//     type Handler = Either<relayed::Handler, Either<direct::Handler, dummy::ConnectionHandler>>;
+//
+//     fn into_handler(self, _remote_peer_id: &PeerId, endpoint: &ConnectedPoint) -> Self::Handler {
+//         match self {
+//             Self::UnknownConnection => {
+//                 if endpoint.is_relayed() {
+//                     Either::Left(relayed::Handler::new(endpoint.clone()))
+//                 } else {
+//                     Either::Right(Either::Right(dummy::ConnectionHandler))
+//                 }
+//             }
+//             Self::DirectConnection {
+//                 relayed_connection_id,
+//                 ..
+//             } => {
+//                 assert!(
+//                     !endpoint.is_relayed(),
+//                     "`Prototype::DirectConnection` is never created for relayed connection."
+//                 );
+//                 Either::Right(Either::Left(direct::Handler::new(relayed_connection_id)))
+//             }
+//         }
+//     }
+//
+//     fn inbound_protocol(&self) -> <Self::Handler as ConnectionHandler>::InboundProtocol {
+//         match self {
+//             Prototype::UnknownConnection => upgrade::EitherUpgrade::A(SendWrapper(
+//                 upgrade::EitherUpgrade::A(protocol::inbound::Upgrade {}),
+//             )),
+//             Prototype::DirectConnection { .. } => {
+//                 upgrade::EitherUpgrade::A(SendWrapper(upgrade::EitherUpgrade::B(DeniedUpgrade)))
+//             }
+//         }
+//     }
+// }