feat(swarm): remove deprecated IntoConnectionHandler

This removes the deprecated `IntoConnectionHandler` trait and all its implementations. Consequently, `NetworkBehaviour::new_handler` and `NetworkBehaviour::addresses_of_peer` are now gone and the two `handle_` functions are now required to implement.

Related: #3647.

Pull-Request: #3884.

Author: thomaseizinger

protocols/identify/src/behaviour.rs

@@ -167,9 +167,6 @@ impl Config {
     }
 
     /// Configures the size of the LRU cache, caching addresses of discovered peers.
-    ///
-    /// The [`Swarm`](libp2p_swarm::Swarm) may extend the set of addresses of an outgoing connection attempt via
-    ///  [`Behaviour::addresses_of_peer`].
     pub fn with_cache_size(mut self, cache_size: usize) -> Self {
         self.cache_size = cache_size;
         self

protocols/rendezvous/src/client.rs

@@ -47,7 +47,7 @@ pub struct Behaviour {
 
     /// Hold addresses of all peers that we have discovered so far.
     ///
-    /// Storing these internally allows us to assist the [`libp2p_swarm::Swarm`] in dialing by returning addresses from [`NetworkBehaviour::addresses_of_peer`].
+    /// Storing these internally allows us to assist the [`libp2p_swarm::Swarm`] in dialing by returning addresses from [`NetworkBehaviour::handle_pending_outbound_connection`].
     discovered_peers: HashMap<(PeerId, Namespace), Vec<Multiaddr>>,
 
     /// Tracks the expiry of registrations that we have discovered and stored in `discovered_peers` otherwise we have a memory leak.

protocols/request-response/src/lib.rs

@@ -417,7 +417,7 @@ where
 
     /// Adds a known address for a peer that can be used for
     /// dialing attempts by the `Swarm`, i.e. is returned
-    /// by [`NetworkBehaviour::addresses_of_peer`].
+    /// by [`NetworkBehaviour::handle_pending_outbound_connection`].
     ///
     /// Addresses added in this way are only removed by `remove_address`.
     pub fn add_address(&mut self, peer: &PeerId, address: Multiaddr) {

swarm/CHANGELOG.md

@@ -18,12 +18,18 @@
   This variant was never constructed and thus dead code.
   See [PR 3605].
 
-[PR 3605]: https://github.com/libp2p/rust-libp2p/pull/3605
-[PR 3746]: https://github.com/libp2p/rust-libp2p/pull/3746
+- Remove deprecated `IntoConnectionHandler` and all its implementations.
+  This also removes the `NetworkBehaviour::new_handler` and `NetworkBehaviour::addresses_of_peer` methods.
+  See changelog for `0.42` on how to migrate.
+  See [PR 3884].
+
 [PR 3715]: https://github.com/libp2p/rust-libp2p/pull/3715
 [PR 3746]: https://github.com/libp2p/rust-libp2p/pull/3746
 [PR 3865]: https://github.com/libp2p/rust-libp2p/pull/3865
 [PR 3886]: https://github.com/libp2p/rust-libp2p/pull/3886
+[PR 3884]: https://github.com/libp2p/rust-libp2p/pull/3884
+[PR 3605]: https://github.com/libp2p/rust-libp2p/pull/3605
+[PR 3746]: https://github.com/libp2p/rust-libp2p/pull/3746
 
 ## 0.42.2
 

swarm/src/behaviour.rs

@@ -28,11 +28,9 @@ pub use listen_addresses::ListenAddresses;
 
 use crate::connection::ConnectionId;
 use crate::dial_opts::DialOpts;
-#[allow(deprecated)]
-use crate::handler::IntoConnectionHandler;
 use crate::{
-    AddressRecord, AddressScore, ConnectionDenied, DialError, ListenError, THandler,
-    THandlerInEvent, THandlerOutEvent,
+    AddressRecord, AddressScore, ConnectionDenied, ConnectionHandler, DialError, ListenError,
+    THandler, THandlerInEvent, THandlerOutEvent,
 };
 use libp2p_core::{transport::ListenerId, ConnectedPoint, Endpoint, Multiaddr};
 use libp2p_identity::PeerId;
@@ -77,9 +75,7 @@ use std::{task::Context, task::Poll};
 /// implementation for the custom `struct`. Each [`NetworkBehaviour`] trait method is simply
 /// delegated to each `struct` member in the order the `struct` is defined. For example for
 /// [`NetworkBehaviour::poll`] it will first poll the first `struct` member until it returns
-/// [`Poll::Pending`] before moving on to later members. For [`NetworkBehaviour::addresses_of_peer`]
-/// it will delegate to each `struct` member and return a concatenated array of all addresses
-/// returned by the struct members.
+/// [`Poll::Pending`] before moving on to later members.
 ///
 /// Events ([`NetworkBehaviour::OutEvent`]) returned by each `struct` member are wrapped in a new
 /// `enum` event, with an `enum` variant for each `struct` member. Users can define this event
@@ -122,37 +118,11 @@ use std::{task::Context, task::Poll};
 /// ```
 pub trait NetworkBehaviour: 'static {
     /// Handler for all the protocols the network behaviour supports.
-    #[allow(deprecated)]
-    type ConnectionHandler: IntoConnectionHandler;
+    type ConnectionHandler: ConnectionHandler;
 
     /// Event generated by the `NetworkBehaviour` and that the swarm will report back.
     type OutEvent: Send + 'static;
 
-    /// Creates a new [`ConnectionHandler`](crate::ConnectionHandler) for a connection with a peer.
-    ///
-    /// Every time an incoming connection is opened, and every time another [`NetworkBehaviour`]
-    /// emitted a dial request, this method is called.
-    ///
-    /// The returned object is a handler for that specific connection, and will be moved to a
-    /// background task dedicated to that connection.
-    ///
-    /// The network behaviour (ie. the implementation of this trait) and the handlers it has spawned
-    /// (ie. the objects returned by `new_handler`) can communicate by passing messages. Messages
-    /// sent from the handler to the behaviour are invoked with
-    /// [`NetworkBehaviour::on_connection_handler_event`],
-    /// and the behaviour can send a message to the handler by making [`NetworkBehaviour::poll`]
-    /// return [`ToSwarm::NotifyHandler`].
-    ///
-    /// Note that the handler is returned to the [`NetworkBehaviour`] on connection failure and
-    /// connection closing.
-    #[deprecated(
-        since = "0.42.0",
-        note = "Use one or more of `NetworkBehaviour::{handle_pending_inbound_connection,handle_established_inbound_connection,handle_pending_outbound_connection,handle_established_outbound_connection}` instead."
-    )]
-    fn new_handler(&mut self) -> Self::ConnectionHandler {
-        panic!("You must implement `handle_established_inbound_connection` and `handle_established_outbound_connection`.")
-    }
-
     /// Callback that is invoked for every new inbound connection.
     ///
     /// At this point in the connection lifecycle, only the remote's and our local address are known.
@@ -181,16 +151,7 @@ pub trait NetworkBehaviour: 'static {
         peer: PeerId,
         local_addr: &Multiaddr,
         remote_addr: &Multiaddr,
-    ) -> Result<THandler<Self>, ConnectionDenied> {
-        #[allow(deprecated)]
-        Ok(self.new_handler().into_handler(
-            &peer,
-            &ConnectedPoint::Listener {
-                local_addr: local_addr.clone(),
-                send_back_addr: remote_addr.clone(),
-            },
-        ))
-    }
+    ) -> Result<THandler<Self>, ConnectionDenied>;
 
     /// Callback that is invoked for every outbound connection attempt.
     ///
@@ -207,16 +168,11 @@ pub trait NetworkBehaviour: 'static {
     fn handle_pending_outbound_connection(
         &mut self,
         _connection_id: ConnectionId,
-        maybe_peer: Option<PeerId>,
+        _maybe_peer: Option<PeerId>,
         _addresses: &[Multiaddr],
         _effective_role: Endpoint,
     ) -> Result<Vec<Multiaddr>, ConnectionDenied> {
-        #[allow(deprecated)]
-        if let Some(peer_id) = maybe_peer {
-            Ok(self.addresses_of_peer(&peer_id))
-        } else {
-            Ok(vec![])
-        }
+        Ok(vec![])
     }
 
     /// Callback that is invoked for every established outbound connection.
@@ -231,27 +187,7 @@ pub trait NetworkBehaviour: 'static {
         peer: PeerId,
         addr: &Multiaddr,
         role_override: Endpoint,
-    ) -> Result<THandler<Self>, ConnectionDenied> {
-        #[allow(deprecated)]
-        Ok(self.new_handler().into_handler(
-            &peer,
-            &ConnectedPoint::Dialer {
-                address: addr.clone(),
-                role_override,
-            },
-        ))
-    }
-
-    /// Addresses that this behaviour is aware of for this specific peer, and that may allow
-    /// reaching the peer.
-    ///
-    /// The addresses will be tried in the order returned by this function, which means that they
-    /// should be ordered by decreasing likelihood of reachability. In other words, the first
-    /// address should be the most likely to be reachable.
-    #[deprecated(note = "Use `NetworkBehaviour::handle_pending_outbound_connection` instead.")]
-    fn addresses_of_peer(&mut self, _: &PeerId) -> Vec<Multiaddr> {
-        vec![]
-    }
+    ) -> Result<THandler<Self>, ConnectionDenied>;
 
     /// Informs the behaviour about an event from the [`Swarm`](crate::Swarm).
     fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>);
@@ -480,7 +416,7 @@ pub enum CloseConnection {
 /// Enumeration with the list of the possible events
 /// to pass to [`on_swarm_event`](NetworkBehaviour::on_swarm_event).
 #[allow(deprecated)]
-pub enum FromSwarm<'a, Handler: IntoConnectionHandler> {
+pub enum FromSwarm<'a, Handler> {
     /// Informs the behaviour about a newly established connection to a peer.
     ConnectionEstablished(ConnectionEstablished<'a>),
     /// Informs the behaviour about a closed connection to a peer.
@@ -535,11 +471,11 @@ pub struct ConnectionEstablished<'a> {
 /// [`FromSwarm::ConnectionEstablished`] with the same peer ID, connection ID
 /// and endpoint.
 #[allow(deprecated)]
-pub struct ConnectionClosed<'a, Handler: IntoConnectionHandler> {
+pub struct ConnectionClosed<'a, Handler> {
     pub peer_id: PeerId,
     pub connection_id: ConnectionId,
     pub endpoint: &'a ConnectedPoint,
-    pub handler: <Handler as IntoConnectionHandler>::Handler,
+    pub handler: Handler,
     pub remaining_established: usize,
 }
 
@@ -625,30 +561,19 @@ pub struct ExpiredExternalAddr<'a> {
     pub addr: &'a Multiaddr,
 }
 
-#[allow(deprecated)]
-impl<'a, Handler: IntoConnectionHandler> FromSwarm<'a, Handler> {
+impl<'a, Handler> FromSwarm<'a, Handler> {
     fn map_handler<NewHandler>(
         self,
-        map_handler: impl FnOnce(
-            <Handler as IntoConnectionHandler>::Handler,
-        ) -> <NewHandler as IntoConnectionHandler>::Handler,
-    ) -> FromSwarm<'a, NewHandler>
-    where
-        NewHandler: IntoConnectionHandler,
-    {
+        map_handler: impl FnOnce(Handler) -> NewHandler,
+    ) -> FromSwarm<'a, NewHandler> {
         self.maybe_map_handler(|h| Some(map_handler(h)))
             .expect("To return Some as all closures return Some.")
     }
 
     fn maybe_map_handler<NewHandler>(
         self,
-        map_handler: impl FnOnce(
-            <Handler as IntoConnectionHandler>::Handler,
-        ) -> Option<<NewHandler as IntoConnectionHandler>::Handler>,
-    ) -> Option<FromSwarm<'a, NewHandler>>
-    where
-        NewHandler: IntoConnectionHandler,
-    {
+        map_handler: impl FnOnce(Handler) -> Option<NewHandler>,
+    ) -> Option<FromSwarm<'a, NewHandler>> {
         match self {
             FromSwarm::ConnectionClosed(ConnectionClosed {
                 peer_id,

swarm/src/behaviour/external_addresses.rs

@@ -1,6 +1,4 @@
 use crate::behaviour::{ExpiredExternalAddr, FromSwarm, NewExternalAddr};
-#[allow(deprecated)]
-use crate::IntoConnectionHandler;
 use libp2p_core::Multiaddr;
 use std::collections::HashSet;
 
@@ -34,11 +32,7 @@ impl ExternalAddresses {
     /// Feed a [`FromSwarm`] event to this struct.
     ///
     /// Returns whether the event changed our set of external addresses.
-    #[allow(deprecated)]
-    pub fn on_swarm_event<THandler>(&mut self, event: &FromSwarm<THandler>) -> bool
-    where
-        THandler: IntoConnectionHandler,
-    {
+    pub fn on_swarm_event<THandler>(&mut self, event: &FromSwarm<THandler>) -> bool {
         match event {
             FromSwarm::NewExternalAddr(NewExternalAddr { addr, .. }) => {
                 if self.addresses.len() < self.limit {

swarm/src/behaviour/listen_addresses.rs

@@ -1,6 +1,4 @@
 use crate::behaviour::{ExpiredListenAddr, FromSwarm, NewListenAddr};
-#[allow(deprecated)]
-use crate::IntoConnectionHandler;
 use libp2p_core::Multiaddr;
 use std::collections::HashSet;
 
@@ -19,11 +17,7 @@ impl ListenAddresses {
     /// Feed a [`FromSwarm`] event to this struct.
     ///
     /// Returns whether the event changed our set of listen addresses.
-    #[allow(deprecated)]
-    pub fn on_swarm_event<THandler>(&mut self, event: &FromSwarm<THandler>) -> bool
-    where
-        THandler: IntoConnectionHandler,
-    {
+    pub fn on_swarm_event<THandler>(&mut self, event: &FromSwarm<THandler>) -> bool {
         match event {
             FromSwarm::NewListenAddr(NewListenAddr { addr, .. }) => {
                 self.addresses.insert((*addr).clone())

swarm/src/connection/pool.rs

@@ -20,8 +20,6 @@
 // DEALINGS IN THE SOFTWARE.
 #[allow(deprecated)]
 use crate::connection::{Connection, ConnectionId, ConnectionLimit, PendingPoint};
-#[allow(deprecated)]
-use crate::IntoConnectionHandler;
 use crate::{
     connection::{
         Connected, ConnectionError, IncomingInfo, PendingConnectionError,
@@ -512,7 +510,7 @@ where
         obtained_peer_id: PeerId,
         endpoint: &ConnectedPoint,
         connection: NewConnection,
-        handler: <THandler as IntoConnectionHandler>::Handler,
+        handler: THandler,
     ) {
         let connection = connection.extract();
 

swarm/src/dial_opts.rs

@@ -207,9 +207,6 @@ impl WithPeerId {
     }
 
     /// Build the final [`DialOpts`].
-    ///
-    /// Addresses to dial the peer are retrieved via
-    /// [`NetworkBehaviour::addresses_of_peer`](crate::behaviour::NetworkBehaviour::addresses_of_peer).
     pub fn build(self) -> DialOpts {
         DialOpts {
             peer_id: Some(self.peer_id),
@@ -241,7 +238,7 @@ impl WithPeerIdWithAddresses {
     }
 
     /// In addition to the provided addresses, extend the set via
-    /// [`NetworkBehaviour::addresses_of_peer`](crate::behaviour::NetworkBehaviour::addresses_of_peer).
+    /// [`NetworkBehaviour::handle_pending_outbound_connection`](crate::behaviour::NetworkBehaviour::handle_pending_outbound_connection).
     pub fn extend_addresses_through_behaviour(mut self) -> Self {
         self.extend_addresses_through_behaviour = true;
         self

swarm/src/handler.rs

@@ -49,15 +49,14 @@ mod select;
 pub use crate::upgrade::{InboundUpgradeSend, OutboundUpgradeSend, SendWrapper, UpgradeInfoSend};
 
 use instant::Instant;
-use libp2p_core::{upgrade::UpgradeError, ConnectedPoint, Multiaddr};
-use libp2p_identity::PeerId;
+use libp2p_core::{upgrade::UpgradeError, Multiaddr};
 use std::{cmp::Ordering, error, fmt, task::Context, task::Poll, time::Duration};
 
 pub use map_in::MapInEvent;
 pub use map_out::MapOutEvent;
 pub use one_shot::{OneShotHandler, OneShotHandlerConfig};
 pub use pending::PendingConnectionHandler;
-pub use select::{ConnectionHandlerSelect, IntoConnectionHandlerSelect};
+pub use select::ConnectionHandlerSelect;
 
 /// A handler for a set of protocols used on a connection with a remote.
 ///
@@ -510,52 +509,6 @@ where
     }
 }
 
-/// Prototype for a [`ConnectionHandler`].
-#[deprecated(
-    note = "Implement `ConnectionHandler` directly and use `NetworkBehaviour::{handle_pending_inbound_connection,handle_pending_outbound_connection}` to handle pending connections."
-)]
-pub trait IntoConnectionHandler: Send + 'static {
-    /// The protocols handler.
-    type Handler: ConnectionHandler;
-
-    /// Builds the protocols handler.
-    ///
-    /// The `PeerId` is the id of the node the handler is going to handle.
-    fn into_handler(
-        self,
-        remote_peer_id: &PeerId,
-        connected_point: &ConnectedPoint,
-    ) -> Self::Handler;
-
-    /// Return the handler's inbound protocol.
-    fn inbound_protocol(&self) -> <Self::Handler as ConnectionHandler>::InboundProtocol;
-
-    /// Builds an implementation of [`IntoConnectionHandler`] that handles both this protocol and the
-    /// other one together.
-    fn select<TProto2>(self, other: TProto2) -> IntoConnectionHandlerSelect<Self, TProto2>
-    where
-        Self: Sized,
-    {
-        IntoConnectionHandlerSelect::new(self, other)
-    }
-}
-
-#[allow(deprecated)]
-impl<T> IntoConnectionHandler for T
-where
-    T: ConnectionHandler,
-{
-    type Handler = Self;
-
-    fn into_handler(self, _: &PeerId, _: &ConnectedPoint) -> Self {
-        self
-    }
-
-    fn inbound_protocol(&self) -> <Self::Handler as ConnectionHandler>::InboundProtocol {
-        self.listen_protocol().into_upgrade().0
-    }
-}
-
 /// How long the connection should be kept alive.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum KeepAlive {