feat(swarm): add ConnectionHandler::connection_keep_alive default implementation

protocols/dcutr/src/handler/relayed.rs

@@ -257,10 +257,6 @@ impl ConnectionHandler for Handler {
             return KeepAlive::Yes;
         }
 
-        if self.inbound_connect.is_some() {
-            return KeepAlive::Yes;
-        }
-
         if self.attempts < MAX_NUMBER_OF_UPGRADE_ATTEMPTS {
             return KeepAlive::Yes;
         }

protocols/gossipsub/src/behaviour.rs

@@ -3265,7 +3265,6 @@ where
     type ConnectionHandler = Handler;
     type ToSwarm = Event;
 
-    #[allow(deprecated)]
     fn handle_established_inbound_connection(
         &mut self,
         _: ConnectionId,
@@ -3276,7 +3275,6 @@ where
         Ok(Handler::new(self.config.protocol_config()))
     }
 
-    #[allow(deprecated)]
     fn handle_established_outbound_connection(
         &mut self,
         _: ConnectionId,

protocols/gossipsub/src/handler.rs

@@ -431,15 +431,6 @@ impl ConnectionHandler for Handler {
                     return KeepAlive::Yes;
                 }
 
-                if let Some(
-                    OutboundSubstreamState::PendingSend(_, _)
-                    | OutboundSubstreamState::PendingFlush(_),
-                ) = handler.outbound_substream
-                {
-                    return KeepAlive::Yes;
-                }
-
-                #[allow(deprecated)]
                 KeepAlive::No
             }
             Handler::Disabled(_) => KeepAlive::No,

protocols/identify/src/handler.rs

@@ -315,10 +315,6 @@ impl ConnectionHandler for Handler {
     }
 
     fn connection_keep_alive(&self) -> KeepAlive {
-        if !self.active_streams.is_empty() {
-            return KeepAlive::Yes;
-        }
-
         KeepAlive::No
     }
 

protocols/kad/src/behaviour/test.rs

@@ -73,7 +73,7 @@ fn build_node_with_config(cfg: Config) -> (Multiaddr, TestSwarm) {
         behaviour,
         local_id,
         swarm::Config::with_async_std_executor()
-            .with_idle_connection_timeout(Duration::from_secs(5)),
+            .with_idle_connection_timeout(Duration::from_secs(10)),
     );
 
     let address: Multiaddr = Protocol::Memory(random::<u64>()).into();

protocols/kad/src/handler.rs

@@ -703,11 +703,7 @@ impl ConnectionHandler for Handler {
     }
 
     fn connection_keep_alive(&self) -> KeepAlive {
-        if self.outbound_substreams.is_empty() && self.inbound_substreams.is_empty() {
-            return KeepAlive::No;
-        };
-
-        KeepAlive::Yes
+        KeepAlive::No
     }
 
     fn poll(

protocols/ping/src/handler.rs

@@ -261,9 +261,10 @@ impl ConnectionHandler for Handler {
                     log::debug!("Inbound ping error: {:?}", e);
                     self.inbound = None;
                 }
-                Poll::Ready(Ok(stream)) => {
+                Poll::Ready(Ok(mut stream)) => {
                     log::trace!("answered inbound ping from {}", self.peer);
 
+                    stream.no_keep_alive();
                     // A ping from a remote peer has been answered, wait for the next.
                     self.inbound = Some(protocol::recv_ping(stream).boxed());
                 }
@@ -294,9 +295,10 @@ impl ConnectionHandler for Handler {
                         self.outbound = Some(OutboundState::Ping(ping));
                         break;
                     }
-                    Poll::Ready(Ok((stream, rtt))) => {
+                    Poll::Ready(Ok((mut stream, rtt))) => {
                         log::debug!("latency to {} is {}ms", self.peer, rtt.as_millis());
 
+                        stream.no_keep_alive();
                         self.failures = 0;
                         self.interval.reset(self.config.interval);
                         self.outbound = Some(OutboundState::Idle(stream));
@@ -307,12 +309,14 @@ impl ConnectionHandler for Handler {
                         self.pending_errors.push_front(e);
                     }
                 },
-                Some(OutboundState::Idle(stream)) => match self.interval.poll_unpin(cx) {
+                Some(OutboundState::Idle(mut stream)) => match self.interval.poll_unpin(cx) {
                     Poll::Pending => {
+                        stream.no_keep_alive();
                         self.outbound = Some(OutboundState::Idle(stream));
                         break;
                     }
                     Poll::Ready(()) => {
+                        stream.no_keep_alive();
                         self.outbound = Some(OutboundState::Ping(
                             send_ping(stream, self.config.timeout).boxed(),
                         ));

protocols/relay/src/behaviour/handler.rs

@@ -376,10 +376,6 @@ pub struct Handler {
     ///
     /// Contains a [`futures::future::Future`] for each lend out substream that
     /// resolves once the substream is dropped.
-    ///
-    /// Once all substreams are dropped and this handler has no other work,
-    /// [`KeepAlive::Until`] can be set, allowing the connection to be closed
-    /// eventually.
     alive_lend_out_substreams: FuturesUnordered<oneshot::Receiver<()>>,
     /// Futures relaying data for circuit between two peers.
     circuits: Futures<(CircuitId, PeerId, Result<(), std::io::Error>)>,
@@ -881,13 +877,7 @@ impl ConnectionHandler for Handler {
         {}
 
         // Check keep alive status.
-        if self.reservation_request_future.is_none()
-            && self.circuit_accept_futures.is_empty()
-            && self.circuit_deny_futures.is_empty()
-            && self.alive_lend_out_substreams.is_empty()
-            && self.circuits.is_empty()
-            && self.active_reservation.is_none()
-        {
+        if self.active_reservation.is_none() {
             if self.idle_at.is_none() {
                 self.idle_at = Some(Instant::now());
             }

protocols/relay/src/priv_client/handler.rs

@@ -324,22 +324,6 @@ impl ConnectionHandler for Handler {
             return KeepAlive::Yes;
         }
 
-        if !self.alive_lend_out_substreams.is_empty() {
-            return KeepAlive::Yes;
-        }
-
-        if !self.circuit_deny_futs.is_empty() {
-            return KeepAlive::Yes;
-        }
-
-        if !self.open_circuit_futs.is_empty() {
-            return KeepAlive::Yes;
-        }
-
-        if !self.outbound_circuits.is_empty() {
-            return KeepAlive::Yes;
-        }
-
         KeepAlive::No
     }
 

protocols/request-response/src/handler.rs

@@ -59,8 +59,6 @@ where
     /// The timeout for inbound and outbound substreams (i.e. request
     /// and response processing).
     substream_timeout: Duration,
-    /// The current connection keep-alive.
-    keep_alive: KeepAlive,
     /// Queue of events to emit in `poll()`.
     pending_events: VecDeque<Event<TCodec>>,
     /// Outbound upgrades waiting to be emitted as an `OutboundSubstreamRequest`.
@@ -94,7 +92,6 @@ where
         Self {
             inbound_protocols,
             codec,
-            keep_alive: KeepAlive::Yes,
             substream_timeout,
             outbound: VecDeque::new(),
             inbound: FuturesUnordered::new(),
@@ -274,12 +271,11 @@ where
     }
 
     fn on_behaviour_event(&mut self, request: Self::FromBehaviour) {
-        self.keep_alive = KeepAlive::Yes;
         self.outbound.push_back(request);
     }
 
     fn connection_keep_alive(&self) -> KeepAlive {
-        self.keep_alive
+        KeepAlive::No
     }
 
     fn poll(
@@ -300,7 +296,6 @@ where
             match result {
                 Ok(((id, rq), rs_sender)) => {
                     // We received an inbound request.
-                    self.keep_alive = KeepAlive::Yes;
                     return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(Event::Request {
                         request_id: id,
                         request: rq,
@@ -330,13 +325,6 @@ where
             self.outbound.shrink_to_fit();
         }
 
-        if self.inbound.is_empty() && self.keep_alive.is_yes() {
-            // No new inbound or outbound requests. We already check
-            // there is no active streams exist in swarm connection,
-            // so we can set keep-alive to no directly.
-            self.keep_alive = KeepAlive::No;
-        }
-
         Poll::Pending
     }
 

swarm/CHANGELOG.md

@@ -6,6 +6,8 @@
   See [PR 4225](https://github.com/libp2p/rust-libp2p/pull/4225).
 - Remove deprecated `keep_alive_timeout` in `OneShotHandlerConfig`.
   See [PR 4677](https://github.com/libp2p/rust-libp2p/pull/4677).
+- Add `ConnectionHandler::connection_keep_alive` default implementation that returns `KeepAlive::No`.
+  See [PR 4703](https://github.com/libp2p/rust-libp2p/pull/4703).
 
 ## 0.43.6