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

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

@@ -439,7 +439,6 @@ impl ConnectionHandler for Handler {
                     return KeepAlive::Yes;
                 }
 
-                #[allow(deprecated)]
                 KeepAlive::No
             }
             Handler::Disabled(_) => KeepAlive::No,

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>)>,

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
 

swarm/src/connection.rs

@@ -52,7 +52,6 @@ use libp2p_core::upgrade;
 use libp2p_core::upgrade::{NegotiationError, ProtocolError};
 use libp2p_core::Endpoint;
 use libp2p_identity::PeerId;
-use std::cmp::max;
 use std::collections::HashSet;
 use std::fmt::{Display, Formatter};
 use std::future::Future;
@@ -450,44 +449,9 @@ fn compute_new_shutdown(
     current_shutdown: &Shutdown,
     idle_timeout: Duration,
 ) -> Option<Shutdown> {
-    #[allow(deprecated)]
     match (current_shutdown, handler_keep_alive) {
-        (Shutdown::Later(_, deadline), KeepAlive::Until(t)) => {
-            let now = Instant::now();
-
-            if *deadline != t {
-                let deadline = t;
-                if let Some(new_duration) = deadline.checked_duration_since(Instant::now()) {
-                    let effective_keep_alive = max(new_duration, idle_timeout);
-
-                    let safe_keep_alive = checked_add_fraction(now, effective_keep_alive);
-                    return Some(Shutdown::Later(Delay::new(safe_keep_alive), deadline));
-                }
-            }
-            None
-        }
-        (_, KeepAlive::Until(earliest_shutdown)) => {
-            let now = Instant::now();
-
-            if let Some(requested) = earliest_shutdown.checked_duration_since(now) {
-                let effective_keep_alive = max(requested, idle_timeout);
-
-                let safe_keep_alive = checked_add_fraction(now, effective_keep_alive);
-
-                // Important: We store the _original_ `Instant` given by the `ConnectionHandler` in the `Later` instance to ensure we can compare it in the above branch.
-                // This is quite subtle but will hopefully become simpler soon once `KeepAlive::Until` is fully deprecated. See <https://github.com/libp2p/rust-libp2p/issues/3844>/
-                return Some(Shutdown::Later(
-                    Delay::new(safe_keep_alive),
-                    earliest_shutdown,
-                ));
-            }
-            None
-        }
         (_, KeepAlive::No) if idle_timeout == Duration::ZERO => Some(Shutdown::Asap),
-        (Shutdown::Later(_, _), KeepAlive::No) => {
-            // Do nothing, i.e. let the shutdown timer continue to tick.
-            None
-        }
+        (Shutdown::Later(_, _), KeepAlive::No) => None, // Do nothing, i.e. let the shutdown timer continue to tick.
         (_, KeepAlive::No) => {
             let now = Instant::now();
             let safe_keep_alive = checked_add_fraction(now, idle_timeout);
@@ -933,68 +897,6 @@ mod tests {
         ));
     }
 
-    #[tokio::test]
-    async fn idle_timeout_with_keep_alive_until_greater_than_idle_timeout() {
-        let idle_timeout = Duration::from_millis(100);
-
-        let mut connection = Connection::new(
-            StreamMuxerBox::new(PendingStreamMuxer),
-            KeepAliveUntilConnectionHandler {
-                until: Instant::now() + idle_timeout * 2,
-            },
-            None,
-            0,
-            idle_timeout,
-        );
-
-        assert!(connection.poll_noop_waker().is_pending());
-
-        tokio::time::sleep(idle_timeout).await;
-
-        assert!(
-            connection.poll_noop_waker().is_pending(),
-            "`KeepAlive::Until` is greater than idle-timeout, continue sleeping"
-        );
-
-        tokio::time::sleep(idle_timeout).await;
-
-        assert!(matches!(
-            connection.poll_noop_waker(),
-            Poll::Ready(Err(ConnectionError::KeepAliveTimeout))
-        ));
-    }
-
-    #[tokio::test]
-    async fn idle_timeout_with_keep_alive_until_less_than_idle_timeout() {
-        let idle_timeout = Duration::from_millis(100);
-
-        let mut connection = Connection::new(
-            StreamMuxerBox::new(PendingStreamMuxer),
-            KeepAliveUntilConnectionHandler {
-                until: Instant::now() + idle_timeout / 2,
-            },
-            None,
-            0,
-            idle_timeout,
-        );
-
-        assert!(connection.poll_noop_waker().is_pending());
-
-        tokio::time::sleep(idle_timeout / 2).await;
-
-        assert!(
-            connection.poll_noop_waker().is_pending(),
-            "`KeepAlive::Until` is less than idle-timeout, honor idle-timeout"
-        );
-
-        tokio::time::sleep(idle_timeout / 2).await;
-
-        assert!(matches!(
-            connection.poll_noop_waker(),
-            Poll::Ready(Err(ConnectionError::KeepAliveTimeout))
-        ));
-    }
-
     #[test]
     fn checked_add_fraction_can_add_u64_max() {
         let _ = env_logger::try_init();
@@ -1058,58 +960,6 @@ mod tests {
         QuickCheck::new().quickcheck(prop as fn(_, _, _));
     }
 
-    struct KeepAliveUntilConnectionHandler {
-        until: Instant,
-    }
-
-    impl ConnectionHandler for KeepAliveUntilConnectionHandler {
-        type FromBehaviour = Void;
-        type ToBehaviour = Void;
-        type Error = Void;
-        type InboundProtocol = DeniedUpgrade;
-        type OutboundProtocol = DeniedUpgrade;
-        type InboundOpenInfo = ();
-        type OutboundOpenInfo = Void;
-
-        fn listen_protocol(
-            &self,
-        ) -> SubstreamProtocol<Self::InboundProtocol, Self::InboundOpenInfo> {
-            SubstreamProtocol::new(DeniedUpgrade, ())
-        }
-
-        fn connection_keep_alive(&self) -> KeepAlive {
-            #[allow(deprecated)]
-            KeepAlive::Until(self.until)
-        }
-
-        fn poll(
-            &mut self,
-            _: &mut Context<'_>,
-        ) -> Poll<
-            ConnectionHandlerEvent<
-                Self::OutboundProtocol,
-                Self::OutboundOpenInfo,
-                Self::ToBehaviour,
-                Self::Error,
-            >,
-        > {
-            Poll::Pending
-        }
-
-        fn on_behaviour_event(&mut self, _: Self::FromBehaviour) {}
-
-        fn on_connection_event(
-            &mut self,
-            _: ConnectionEvent<
-                Self::InboundProtocol,
-                Self::OutboundProtocol,
-                Self::InboundOpenInfo,
-                Self::OutboundOpenInfo,
-            >,
-        ) {
-        }
-    }
-
     struct DummyStreamMuxer {
         counter: Arc<()>,
     }

swarm/src/handler.rs

@@ -55,7 +55,6 @@ pub use select::ConnectionHandlerSelect;
 
 use crate::StreamProtocol;
 use ::either::Either;
-use instant::Instant;
 use libp2p_core::Multiaddr;
 use once_cell::sync::Lazy;
 use smallvec::SmallVec;
@@ -125,25 +124,23 @@ pub trait ConnectionHandler: Send + 'static {
 
     /// Returns until when the connection should be kept alive.
     ///
-    /// This method is called by the `Swarm` after each invocation of
-    /// [`ConnectionHandler::poll`] to determine if the connection and the associated
-    /// [`ConnectionHandler`]s should be kept alive as far as this handler is concerned
-    /// and if so, for how long.
+    /// This method is an optional implementation and can be called by the `Swarm` after
+    /// each invocation of [`ConnectionHandler::poll`] to determine if the connection
+    /// and the associated [`ConnectionHandler`]s should be kept alive.
     ///
     /// Returning [`KeepAlive::No`] indicates that the connection should be
     /// closed and this handler destroyed immediately.
     ///
-    /// Returning [`KeepAlive::Until`] indicates that the connection may be closed
-    /// and this handler destroyed after the specified `Instant`.
-    ///
     /// Returning [`KeepAlive::Yes`] indicates that the connection should
     /// be kept alive until the next call to this method.
     ///
     /// > **Note**: The connection is always closed and the handler destroyed
     /// > when [`ConnectionHandler::poll`] returns an error. Furthermore, the
     /// > connection may be closed for reasons outside of the control
     /// > of the handler.
-    fn connection_keep_alive(&self) -> KeepAlive;
+    fn connection_keep_alive(&self) -> KeepAlive {
+        KeepAlive::No
+    }
 
     /// Should behave like `Stream::poll()`.
     fn poll(
@@ -727,11 +724,6 @@ where
 /// How long the connection should be kept alive.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum KeepAlive {
-    /// If nothing new happens, the connection should be closed at the given `Instant`.
-    #[deprecated(
-        note = "Use `swarm::Config::with_idle_connection_timeout` instead. See <https://github.com/libp2p/rust-libp2p/issues/3844> for details."
-    )]
-    Until(Instant),
     /// Keep the connection alive.
     Yes,
     /// Close the connection as soon as possible.
@@ -751,35 +743,24 @@ impl PartialOrd for KeepAlive {
     }
 }
 
-#[allow(deprecated)]
 impl Ord for KeepAlive {
     fn cmp(&self, other: &KeepAlive) -> Ordering {
         use self::KeepAlive::*;
 
         match (self, other) {
             (No, No) | (Yes, Yes) => Ordering::Equal,
-            (No, _) | (_, Yes) => Ordering::Less,
-            (_, No) | (Yes, _) => Ordering::Greater,
-            (Until(t1), Until(t2)) => t1.cmp(t2),
+            (Yes, No) => Ordering::Less,
+            (No, Yes) => Ordering::Greater,
         }
     }
 }
 
 #[cfg(test)]
 impl quickcheck::Arbitrary for KeepAlive {
     fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-        match quickcheck::GenRange::gen_range(g, 1u8..4) {
-            1 =>
-            {
-                #[allow(deprecated)]
-                KeepAlive::Until(
-                    Instant::now()
-                        .checked_add(Duration::arbitrary(g))
-                        .unwrap_or(Instant::now()),
-                )
-            }
-            2 => KeepAlive::Yes,
-            3 => KeepAlive::No,
+        match quickcheck::GenRange::gen_range(g, 1u8..3) {
+            1 => KeepAlive::Yes,
+            2 => KeepAlive::No,
             _ => unreachable!(),
         }
     }

swarm/src/handler/one_shot.rs

@@ -230,7 +230,6 @@ pub struct OneShotHandlerConfig {
 }
 
 impl Default for OneShotHandlerConfig {
-    #[allow(deprecated)]
     fn default() -> Self {
         OneShotHandlerConfig {
             outbound_substream_timeout: Duration::from_secs(10),
@@ -249,7 +248,6 @@ mod tests {
     use void::Void;
 
     #[test]
-    #[allow(deprecated)]
     fn do_not_keep_idle_connection_alive() {
         let mut handler: OneShotHandler<_, DeniedUpgrade, Void> = OneShotHandler::new(
             SubstreamProtocol::new(DeniedUpgrade {}, ()),