swarm/: Rename ProtocolsHandler to ConnectionHandler (libp2p#2527)

A `ProtocolsHandler`, now `ConnectionHandler`, handels a connection, not
a protocol. Thus the name `CONNECTIONHandler` is more appropriate.

Next to the rename of `ProtocolsHandler` this commit renames the `mod
protocols_handler` to `mod handler`. Finally all combinators (e.g.
`ProtocolsHandlerSelect`) are renamed appropriately.

Author: mxinden

README.md

@@ -43,7 +43,7 @@ The main components of this repository are structured as follows:
     Multiplexing protocols are (mandatory) `Transport` upgrades.
 
   * `swarm/`: The implementation of `libp2p-swarm` building on `libp2p-core`
-    with the central interfaces `NetworkBehaviour` and `ProtocolsHandler` used
+    with the central interfaces `NetworkBehaviour` and `ConnectionHandler` used
     to implement application protocols (see `protocols/`).
 
   * `protocols/`: Implementations of application protocols based on the

core/src/upgrade.rs

@@ -53,7 +53,7 @@
 //!
 //! > **Note**: You can use the `apply_inbound` or `apply_outbound` methods to try upgrade a
 //!             connection or substream. However if you use the recommended `Swarm` or
-//!             `ProtocolsHandler` APIs, the upgrade is automatically handled for you and you don't
+//!             `ConnectionHandler` APIs, the upgrade is automatically handled for you and you don't
 //!             need to use these methods.
 //!
 

examples/file-sharing.rs

@@ -217,7 +217,7 @@ mod network {
         ProtocolSupport, RequestId, RequestResponse, RequestResponseCodec, RequestResponseEvent,
         RequestResponseMessage, ResponseChannel,
     };
-    use libp2p::swarm::{ProtocolsHandlerUpgrErr, SwarmBuilder, SwarmEvent};
+    use libp2p::swarm::{ConnectionHandlerUpgrErr, SwarmBuilder, SwarmEvent};
     use libp2p::{NetworkBehaviour, Swarm};
     use std::collections::{HashMap, HashSet};
     use std::iter;
@@ -404,7 +404,7 @@ mod network {
             &mut self,
             event: SwarmEvent<
                 ComposedEvent,
-                EitherError<ProtocolsHandlerUpgrErr<io::Error>, io::Error>,
+                EitherError<ConnectionHandlerUpgrErr<io::Error>, io::Error>,
             >,
         ) {
             match event {

protocols/autonat/src/behaviour.rs

@@ -37,7 +37,7 @@ use libp2p_request_response::{
     RequestResponseConfig, RequestResponseEvent, RequestResponseMessage, ResponseChannel,
 };
 use libp2p_swarm::{
-    DialError, IntoProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
+    DialError, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::{HashMap, VecDeque},
@@ -294,7 +294,7 @@ impl Behaviour {
 }
 
 impl NetworkBehaviour for Behaviour {
-    type ProtocolsHandler = <RequestResponse<AutoNatCodec> as NetworkBehaviour>::ProtocolsHandler;
+    type ConnectionHandler = <RequestResponse<AutoNatCodec> as NetworkBehaviour>::ConnectionHandler;
     type OutEvent = Event;
 
     fn inject_connection_established(
@@ -347,7 +347,7 @@ impl NetworkBehaviour for Behaviour {
         peer: &PeerId,
         conn: &ConnectionId,
         endpoint: &ConnectedPoint,
-        handler: <Self::ProtocolsHandler as IntoProtocolsHandler>::Handler,
+        handler: <Self::ConnectionHandler as IntoConnectionHandler>::Handler,
         remaining_established: usize,
     ) {
         self.inner
@@ -363,7 +363,7 @@ impl NetworkBehaviour for Behaviour {
     fn inject_dial_failure(
         &mut self,
         peer: Option<PeerId>,
-        handler: Self::ProtocolsHandler,
+        handler: Self::ConnectionHandler,
         error: &DialError,
     ) {
         self.inner.inject_dial_failure(peer, handler, error);
@@ -459,7 +459,7 @@ impl NetworkBehaviour for Behaviour {
         }
     }
 
-    fn new_handler(&mut self) -> Self::ProtocolsHandler {
+    fn new_handler(&mut self) -> Self::ConnectionHandler {
         self.inner.new_handler()
     }
 
@@ -480,7 +480,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         local_addr: &Multiaddr,
         send_back_addr: &Multiaddr,
-        handler: Self::ProtocolsHandler,
+        handler: Self::ConnectionHandler,
     ) {
         self.inner
             .inject_listen_failure(local_addr, send_back_addr, handler)
@@ -501,7 +501,7 @@ impl NetworkBehaviour for Behaviour {
 
 type Action = NetworkBehaviourAction<
     <Behaviour as NetworkBehaviour>::OutEvent,
-    <Behaviour as NetworkBehaviour>::ProtocolsHandler,
+    <Behaviour as NetworkBehaviour>::ConnectionHandler,
 >;
 
 // Trait implemented for `AsClient` as `AsServer` to handle events from the inner [`RequestResponse`] Protocol.

protocols/dcutr/src/behaviour.rs

@@ -28,8 +28,8 @@ use libp2p_core::multiaddr::Protocol;
 use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::dial_opts::{self, DialOpts};
 use libp2p_swarm::{
-    DialError, IntoProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
-    PollParameters, ProtocolsHandler, ProtocolsHandlerUpgrErr,
+    ConnectionHandler, ConnectionHandlerUpgrErr, DialError, IntoConnectionHandler,
+    NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::task::{Context, Poll};
@@ -62,7 +62,7 @@ pub enum UpgradeError {
     #[error("Failed to dial peer.")]
     Dial,
     #[error("Failed to establish substream: {0}.")]
-    Handler(ProtocolsHandlerUpgrErr<void::Void>),
+    Handler(ConnectionHandlerUpgrErr<void::Void>),
 }
 
 pub struct Behaviour {
@@ -83,10 +83,10 @@ impl Behaviour {
 }
 
 impl NetworkBehaviour for Behaviour {
-    type ProtocolsHandler = handler::Prototype;
+    type ConnectionHandler = handler::Prototype;
     type OutEvent = Event;
 
-    fn new_handler(&mut self) -> Self::ProtocolsHandler {
+    fn new_handler(&mut self) -> Self::ConnectionHandler {
         handler::Prototype::UnknownConnection
     }
 
@@ -142,7 +142,7 @@ impl NetworkBehaviour for Behaviour {
     fn inject_dial_failure(
         &mut self,
         peer_id: Option<PeerId>,
-        handler: Self::ProtocolsHandler,
+        handler: Self::ConnectionHandler,
         _error: &DialError,
     ) {
         match handler {
@@ -187,7 +187,7 @@ impl NetworkBehaviour for Behaviour {
         peer_id: &PeerId,
         connection_id: &ConnectionId,
         connected_point: &ConnectedPoint,
-        _handler: <<Self as NetworkBehaviour>::ProtocolsHandler as IntoProtocolsHandler>::Handler,
+        _handler: <<Self as NetworkBehaviour>::ConnectionHandler as IntoConnectionHandler>::Handler,
         _remaining_established: usize,
     ) {
         if !connected_point.is_relayed() {
@@ -209,7 +209,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         event_source: PeerId,
         connection: ConnectionId,
-        handler_event: <<Self::ProtocolsHandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent,
+        handler_event: <<Self::ConnectionHandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutEvent,
     ) {
         match handler_event {
             Either::Left(handler::relayed::Event::InboundConnectRequest {
@@ -313,7 +313,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         _cx: &mut Context<'_>,
         poll_parameters: &mut impl PollParameters,
-    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ProtocolsHandler>> {
+    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ConnectionHandler>> {
         if let Some(action) = self.queued_actions.pop_front() {
             return Poll::Ready(action.build(poll_parameters));
         }

protocols/dcutr/src/handler.rs

@@ -23,9 +23,9 @@ use either::Either;
 use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::{self, DeniedUpgrade};
 use libp2p_core::{ConnectedPoint, PeerId};
-use libp2p_swarm::protocols_handler::DummyProtocolsHandler;
-use libp2p_swarm::protocols_handler::SendWrapper;
-use libp2p_swarm::{IntoProtocolsHandler, ProtocolsHandler};
+use libp2p_swarm::handler::DummyConnectionHandler;
+use libp2p_swarm::handler::SendWrapper;
+use libp2p_swarm::{ConnectionHandler, IntoConnectionHandler};
 
 pub mod direct;
 pub mod relayed;
@@ -43,16 +43,16 @@ pub enum Role {
     Listener,
 }
 
-impl IntoProtocolsHandler for Prototype {
-    type Handler = Either<relayed::Handler, Either<direct::Handler, DummyProtocolsHandler>>;
+impl IntoConnectionHandler for Prototype {
+    type Handler = Either<relayed::Handler, Either<direct::Handler, DummyConnectionHandler>>;
 
     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(DummyProtocolsHandler::default()))
+                    Either::Right(Either::Right(DummyConnectionHandler::default()))
                 }
             }
             Self::DirectConnection {
@@ -68,7 +68,7 @@ impl IntoProtocolsHandler for Prototype {
         }
     }
 
-    fn inbound_protocol(&self) -> <Self::Handler as ProtocolsHandler>::InboundProtocol {
+    fn inbound_protocol(&self) -> <Self::Handler as ConnectionHandler>::InboundProtocol {
         match self {
             Prototype::UnknownConnection => upgrade::EitherUpgrade::A(SendWrapper(
                 upgrade::EitherUpgrade::A(protocol::inbound::Upgrade {}),

protocols/dcutr/src/handler/direct.rs

@@ -18,13 +18,13 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-//! [`ProtocolsHandler`] handling direct connection upgraded through a relayed connection.
+//! [`ConnectionHandler`] handling direct connection upgraded through a relayed connection.
 
 use libp2p_core::connection::ConnectionId;
 use libp2p_core::upgrade::{DeniedUpgrade, InboundUpgrade, OutboundUpgrade};
 use libp2p_swarm::{
-    KeepAlive, NegotiatedSubstream, ProtocolsHandler, ProtocolsHandlerEvent,
-    ProtocolsHandlerUpgrErr, SubstreamProtocol,
+    ConnectionHandler, ConnectionHandlerEvent, ConnectionHandlerUpgrErr, KeepAlive,
+    NegotiatedSubstream, SubstreamProtocol,
 };
 use std::task::{Context, Poll};
 use void::Void;
@@ -48,10 +48,10 @@ impl Handler {
     }
 }
 
-impl ProtocolsHandler for Handler {
+impl ConnectionHandler for Handler {
     type InEvent = void::Void;
     type OutEvent = Event;
-    type Error = ProtocolsHandlerUpgrErr<std::io::Error>;
+    type Error = ConnectionHandlerUpgrErr<std::io::Error>;
     type InboundProtocol = DeniedUpgrade;
     type OutboundProtocol = DeniedUpgrade;
     type OutboundOpenInfo = Void;
@@ -80,7 +80,7 @@ impl ProtocolsHandler for Handler {
     fn inject_dial_upgrade_error(
         &mut self,
         _: Self::OutboundOpenInfo,
-        _: ProtocolsHandlerUpgrErr<
+        _: ConnectionHandlerUpgrErr<
             <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Error,
         >,
     ) {
@@ -94,7 +94,7 @@ impl ProtocolsHandler for Handler {
         &mut self,
         _: &mut Context<'_>,
     ) -> Poll<
-        ProtocolsHandlerEvent<
+        ConnectionHandlerEvent<
             Self::OutboundProtocol,
             Self::OutboundOpenInfo,
             Self::OutEvent,
@@ -103,7 +103,7 @@ impl ProtocolsHandler for Handler {
     > {
         if !self.reported {
             self.reported = true;
-            return Poll::Ready(ProtocolsHandlerEvent::Custom(
+            return Poll::Ready(ConnectionHandlerEvent::Custom(
                 Event::DirectConnectionUpgradeSucceeded {
                     relayed_connection_id: self.relayed_connection_id,
                 },