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

misc/metrics/src/swarm.rs

@@ -31,6 +31,8 @@ pub struct Metrics {
     connections_established: Family<ConnectionEstablishedLabels, Counter>,
     connections_closed: Family<ConnectionClosedLabels, Counter>,
 
+    connections_denied: Family<AddressLabels, Counter>,
+
     new_listen_addr: Family<AddressLabels, Counter>,
     expired_listen_addr: Family<AddressLabels, Counter>,
 
@@ -60,6 +62,13 @@ impl Metrics {
             Box::new(connections_incoming_error.clone()),
         );
 
+        let connections_denied = Family::default();
+        sub_registry.register(
+            "connections_denied",
+            "Number of denied connections",
+            Box::new(connections_denied.clone()),
+        );
+
         let new_listen_addr = Family::default();
         sub_registry.register(
             "new_listen_addr",
@@ -128,6 +137,7 @@ impl Metrics {
             connections_incoming_error,
             connections_established,
             connections_closed,
+            connections_denied,
             new_listen_addr,
             expired_listen_addr,
             listener_closed,
@@ -269,6 +279,13 @@ impl<TBvEv, THandleErr> super::Recorder<libp2p_swarm::SwarmEvent<TBvEv, THandleE
             libp2p_swarm::SwarmEvent::Dialing(_) => {
                 self.dial_attempt.inc();
             }
+            libp2p_swarm::SwarmEvent::ConnectionDenied { endpoint, .. } => {
+                self.connections_denied
+                    .get_or_create(&AddressLabels {
+                        protocols: protocol_stack::as_string(endpoint.get_remote_address()),
+                    })
+                    .inc();
+            }
         }
     }
 }

protocols/autonat/src/behaviour.rs

@@ -35,14 +35,15 @@ use libp2p_request_response::{
     ProtocolSupport, RequestId, RequestResponse, RequestResponseConfig, RequestResponseEvent,
     RequestResponseMessage, ResponseChannel,
 };
+use libp2p_swarm::behaviour::THandlerInEvent;
 use libp2p_swarm::{
     behaviour::{
         AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, ExpiredExternalAddr,
         ExpiredListenAddr, FromSwarm,
     },
-    ConnectionHandler, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction,
-    PollParameters,
+    ConnectionHandler,
 };
+use libp2p_swarm::{NetworkBehaviour, NetworkBehaviourAction, PollParameters};
 use std::{
     collections::{HashMap, VecDeque},
     iter,
@@ -374,20 +375,9 @@ impl Behaviour {
         }
     }
 
-    fn on_dial_failure(
-        &mut self,
-        DialFailure {
-            peer_id,
-            handler,
-            error,
-        }: DialFailure<<Self as NetworkBehaviour>::ConnectionHandler>,
-    ) {
+    fn on_dial_failure(&mut self, DialFailure { peer_id, error }: DialFailure) {
         self.inner
-            .on_swarm_event(FromSwarm::DialFailure(DialFailure {
-                peer_id,
-                handler,
-                error,
-            }));
+            .on_swarm_event(FromSwarm::DialFailure(DialFailure { 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));
@@ -467,8 +457,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,
+    ) -> Result<Self::ConnectionHandler, Box<dyn std::error::Error + Send + 'static>> {
+        self.inner.new_handler(peer, connected_point)
     }
 
     fn addresses_of_peer(&mut self, peer: &PeerId) -> Vec<Multiaddr> {
@@ -529,8 +523,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         peer_id: PeerId,
         connection_id: ConnectionId,
-        event:  <<Self::ConnectionHandler as IntoConnectionHandler>::Handler as
-    ConnectionHandler>::OutEvent,
+        event: <Self::ConnectionHandler as ConnectionHandler>::OutEvent,
     ) {
         self.inner
             .on_connection_handler_event(peer_id, connection_id, event)
@@ -539,7 +532,7 @@ impl NetworkBehaviour for Behaviour {
 
 type Action = NetworkBehaviourAction<
     <Behaviour as NetworkBehaviour>::OutEvent,
-    <Behaviour as NetworkBehaviour>::ConnectionHandler,
+    THandlerInEvent<<Behaviour as NetworkBehaviour>::ConnectionHandler>,
 >;
 
 // Trait implemented for `AsClient` as `AsServer` to handle events from the inner [`RequestResponse`] Protocol.

protocols/autonat/src/behaviour/as_server.rs

@@ -30,7 +30,7 @@ use libp2p_request_response::{
 };
 use libp2p_swarm::{
     dial_opts::{DialOpts, PeerCondition},
-    DialError, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    DialError, NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::{HashMap, HashSet, VecDeque},
@@ -137,7 +137,6 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                                 .override_dial_concurrency_factor(NonZeroU8::new(1).expect("1 > 0"))
                                 .addresses(addrs)
                                 .build(),
-                            handler: self.inner.new_handler(),
                         });
                     }
                     Err((status_text, error)) => {