swarm(-derive)/: Rename references of protocol handler to connection handler (#2640)

swarm-derive/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.27.2 [unreleased]
+
+- Replace references of Protocol Handler with Connection Handler. See [PR 2640].
+
+[PR 2640]: https://github.com/libp2p/rust-libp2p/pull/2640
+
 # 0.27.1
 
 - Allow mixing of ignored fields. See [PR 2570].

swarm-derive/Cargo.toml

@@ -3,7 +3,7 @@ name = "libp2p-swarm-derive"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Procedural macros of libp2p-core"
-version = "0.27.1"
+version = "0.27.2"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

swarm-derive/src/lib.rs

@@ -50,8 +50,8 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
     let net_behv_event_proc = quote! {::libp2p::swarm::NetworkBehaviourEventProcess};
     let either_ident = quote! {::libp2p::core::either::EitherOutput};
     let network_behaviour_action = quote! {::libp2p::swarm::NetworkBehaviourAction};
-    let into_protocols_handler = quote! {::libp2p::swarm::IntoConnectionHandler};
-    let protocols_handler = quote! {::libp2p::swarm::ConnectionHandler};
+    let into_connection_handler = quote! {::libp2p::swarm::IntoConnectionHandler};
+    let connection_handler = quote! {::libp2p::swarm::ConnectionHandler};
     let into_proto_select_ident = quote! {::libp2p::swarm::IntoConnectionHandlerSelect};
     let peer_id = quote! {::libp2p::core::PeerId};
     let connection_id = quote! {::libp2p::core::connection::ConnectionId};
@@ -371,7 +371,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
     });
 
     // The [`ConnectionHandler`] associated type.
-    let protocols_handler_ty = {
+    let connection_handler_ty = {
         let mut ph_ty = None;
         for field in data_struct_fields.iter() {
             let ty = &field.ty;
@@ -402,7 +402,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
 
             match out_handler {
                 Some(h) => {
-                    out_handler = Some(quote! { #into_protocols_handler::select(#h, #builder) })
+                    out_handler = Some(quote! { #into_connection_handler::select(#h, #builder) })
                 }
                 ref mut h @ None => *h = Some(builder),
             }
@@ -476,7 +476,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
 
                 match out_handler {
                     Some(h) => {
-                        out_handler = Some(quote! { #into_protocols_handler::select(#h, #builder) })
+                        out_handler = Some(quote! { #into_connection_handler::select(#h, #builder) })
                     }
                     ref mut h @ None => *h = Some(builder),
                 }
@@ -530,11 +530,11 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
         impl #impl_generics #trait_to_impl for #name #ty_generics
         #where_clause
         {
-            type ConnectionHandler = #protocols_handler_ty;
+            type ConnectionHandler = #connection_handler_ty;
             type OutEvent = #out_event;
 
             fn new_handler(&mut self) -> Self::ConnectionHandler {
-                use #into_protocols_handler;
+                use #into_connection_handler;
                 #new_handler
             }
 
@@ -552,7 +552,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
                 #(#inject_address_change_stmts);*
             }
 
-            fn inject_connection_closed(&mut self, peer_id: &#peer_id, connection_id: &#connection_id, endpoint: &#connected_point, handlers: <Self::ConnectionHandler as #into_protocols_handler>::Handler, remaining_established: usize) {
+            fn inject_connection_closed(&mut self, peer_id: &#peer_id, connection_id: &#connection_id, endpoint: &#connected_point, handlers: <Self::ConnectionHandler as #into_connection_handler>::Handler, remaining_established: usize) {
                 #(#inject_connection_closed_stmts);*
             }
 
@@ -596,7 +596,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
                 &mut self,
                 peer_id: #peer_id,
                 connection_id: #connection_id,
-                event: <<Self::ConnectionHandler as #into_protocols_handler>::Handler as #protocols_handler>::OutEvent
+                event: <<Self::ConnectionHandler as #into_connection_handler>::Handler as #connection_handler>::OutEvent
             ) {
                 match event {
                     #(#inject_node_event_stmts),*

swarm/CHANGELOG.md

@@ -8,9 +8,12 @@
 
 - Rename `IncomingInfo::to_connected_point` to `IncomingInfo::create_connected_point`. See [PR 2620].
 
+- Rename `TProtoHandler` to `TConnectionHandler`, `ToggleProtoHandler` to `ToggleConnectionHandler`, `ToggleIntoProtoHandler` to `ToggleIntoConnectionHandler`. See [PR 2640].
+
 [PR 2529]: https://github.com/libp2p/rust-libp2p/pull/2529
 [PR 2610]: https://github.com/libp2p/rust-libp2p/pull/2610
 [PR 2620]: https://github.com/libp2p/rust-libp2p/pull/2620
+[PR 2640]: https://github.com/libp2p/rust-libp2p/pull/2640
 
 # 0.35.0
 

swarm/src/behaviour/toggle.rs

@@ -70,11 +70,11 @@ impl<TBehaviour> NetworkBehaviour for Toggle<TBehaviour>
 where
     TBehaviour: NetworkBehaviour,
 {
-    type ConnectionHandler = ToggleIntoProtoHandler<TBehaviour::ConnectionHandler>;
+    type ConnectionHandler = ToggleIntoConnectionHandler<TBehaviour::ConnectionHandler>;
     type OutEvent = TBehaviour::OutEvent;
 
     fn new_handler(&mut self) -> Self::ConnectionHandler {
-        ToggleIntoProtoHandler {
+        ToggleIntoConnectionHandler {
             inner: self.inner.as_mut().map(|i| i.new_handler()),
         }
     }
@@ -223,9 +223,9 @@ where
         params: &mut impl PollParameters,
     ) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ConnectionHandler>> {
         if let Some(inner) = self.inner.as_mut() {
-            inner
-                .poll(cx, params)
-                .map(|action| action.map_handler(|h| ToggleIntoProtoHandler { inner: Some(h) }))
+            inner.poll(cx, params).map(|action| {
+                action.map_handler(|h| ToggleIntoConnectionHandler { inner: Some(h) })
+            })
         } else {
             Poll::Pending
         }
@@ -244,22 +244,22 @@ where
 }
 
 /// Implementation of `IntoConnectionHandler` that can be in the disabled state.
-pub struct ToggleIntoProtoHandler<TInner> {
+pub struct ToggleIntoConnectionHandler<TInner> {
     inner: Option<TInner>,
 }
 
-impl<TInner> IntoConnectionHandler for ToggleIntoProtoHandler<TInner>
+impl<TInner> IntoConnectionHandler for ToggleIntoConnectionHandler<TInner>
 where
     TInner: IntoConnectionHandler,
 {
-    type Handler = ToggleProtoHandler<TInner::Handler>;
+    type Handler = ToggleConnectionHandler<TInner::Handler>;
 
     fn into_handler(
         self,
         remote_peer_id: &PeerId,
         connected_point: &ConnectedPoint,
     ) -> Self::Handler {
-        ToggleProtoHandler {
+        ToggleConnectionHandler {
             inner: self
                 .inner
                 .map(|h| h.into_handler(remote_peer_id, connected_point)),
@@ -276,11 +276,11 @@ where
 }
 
 /// Implementation of [`ConnectionHandler`] that can be in the disabled state.
-pub struct ToggleProtoHandler<TInner> {
+pub struct ToggleConnectionHandler<TInner> {
     inner: Option<TInner>,
 }
 
-impl<TInner> ConnectionHandler for ToggleProtoHandler<TInner>
+impl<TInner> ConnectionHandler for ToggleConnectionHandler<TInner>
 where
     TInner: ConnectionHandler,
 {
@@ -426,7 +426,7 @@ mod tests {
     use super::*;
     use crate::handler::DummyConnectionHandler;
 
-    /// A disabled [`ToggleProtoHandler`] can receive listen upgrade errors in
+    /// A disabled [`ToggleConnectionHandler`] can receive listen upgrade errors in
     /// the following two cases:
     ///
     /// 1. Protocol negotiation on an incoming stream failed with no protocol
@@ -435,14 +435,14 @@ mod tests {
     /// 2. When combining [`ConnectionHandler`] implementations a single
     ///    [`ConnectionHandler`] might be notified of an inbound upgrade error
     ///    unrelated to its own upgrade logic. For example when nesting a
-    ///    [`ToggleProtoHandler`] in a
-    ///    [`ConnectionHandlerSelect`](crate::protocols_handler::ConnectionHandlerSelect)
+    ///    [`ToggleConnectionHandler`] in a
+    ///    [`ConnectionHandlerSelect`](crate::connection_handler::ConnectionHandlerSelect)
     ///    the former might receive an inbound upgrade error even when disabled.
     ///
-    /// [`ToggleProtoHandler`] should ignore the error in both of these cases.
+    /// [`ToggleConnectionHandler`] should ignore the error in both of these cases.
     #[test]
     fn ignore_listen_upgrade_error_when_disabled() {
-        let mut handler = ToggleProtoHandler::<DummyConnectionHandler> { inner: None };
+        let mut handler = ToggleConnectionHandler::<DummyConnectionHandler> { inner: None };
 
         handler.inject_listen_upgrade_error(Either::Right(()), ConnectionHandlerUpgrErr::Timeout);
     }

swarm/src/connection.rs

@@ -113,7 +113,10 @@ where
     /// Begins an orderly shutdown of the connection, returning the connection
     /// handler and a `Future` that resolves when connection shutdown is complete.
     pub fn close(self) -> (THandler, Close<StreamMuxerBox>) {
-        (self.handler.into_protocols_handler(), self.muxing.close().0)
+        (
+            self.handler.into_connection_handler(),
+            self.muxing.close().0,
+        )
     }
 
     /// Polls the handler and the substream, forwarding events from the former to the latter and

swarm/src/connection/handler_wrapper.rs

@@ -42,35 +42,35 @@ use std::{error, fmt, pin::Pin, task::Context, task::Poll, time::Duration};
 /// - Driving substream upgrades
 /// - Handling connection timeout
 // TODO: add a caching system for protocols that are supported or not
-pub struct HandlerWrapper<TProtoHandler>
+pub struct HandlerWrapper<TConnectionHandler>
 where
-    TProtoHandler: ConnectionHandler,
+    TConnectionHandler: ConnectionHandler,
 {
     /// The underlying handler.
-    handler: TProtoHandler,
+    handler: TConnectionHandler,
     /// Futures that upgrade incoming substreams.
     negotiating_in: FuturesUnordered<
         SubstreamUpgrade<
-            TProtoHandler::InboundOpenInfo,
+            TConnectionHandler::InboundOpenInfo,
             InboundUpgradeApply<
                 Substream<StreamMuxerBox>,
-                SendWrapper<TProtoHandler::InboundProtocol>,
+                SendWrapper<TConnectionHandler::InboundProtocol>,
             >,
         >,
     >,
     /// Futures that upgrade outgoing substreams.
     negotiating_out: FuturesUnordered<
         SubstreamUpgrade<
-            TProtoHandler::OutboundOpenInfo,
+            TConnectionHandler::OutboundOpenInfo,
             OutboundUpgradeApply<
                 Substream<StreamMuxerBox>,
-                SendWrapper<TProtoHandler::OutboundProtocol>,
+                SendWrapper<TConnectionHandler::OutboundProtocol>,
             >,
         >,
     >,
     /// For each outbound substream request, how to upgrade it. The first element of the tuple
     /// is the unique identifier (see `unique_dial_upgrade_id`).
-    queued_dial_upgrades: Vec<(u64, SendWrapper<TProtoHandler::OutboundProtocol>)>,
+    queued_dial_upgrades: Vec<(u64, SendWrapper<TConnectionHandler::OutboundProtocol>)>,
     /// Unique identifier assigned to each queued dial upgrade.
     unique_dial_upgrade_id: u64,
     /// The currently planned connection & handler shutdown.
@@ -79,7 +79,7 @@ where
     substream_upgrade_protocol_override: Option<upgrade::Version>,
 }
 
-impl<TProtoHandler: ConnectionHandler> std::fmt::Debug for HandlerWrapper<TProtoHandler> {
+impl<TConnectionHandler: ConnectionHandler> std::fmt::Debug for HandlerWrapper<TConnectionHandler> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("HandlerWrapper")
             .field("negotiating_in", &self.negotiating_in)
@@ -94,9 +94,9 @@ impl<TProtoHandler: ConnectionHandler> std::fmt::Debug for HandlerWrapper<TProto
     }
 }
 
-impl<TProtoHandler: ConnectionHandler> HandlerWrapper<TProtoHandler> {
+impl<TConnectionHandler: ConnectionHandler> HandlerWrapper<TConnectionHandler> {
     pub(crate) fn new(
-        handler: TProtoHandler,
+        handler: TConnectionHandler,
         substream_upgrade_protocol_override: Option<upgrade::Version>,
     ) -> Self {
         Self {
@@ -110,7 +110,7 @@ impl<TProtoHandler: ConnectionHandler> HandlerWrapper<TProtoHandler> {
         }
     }
 
-    pub(crate) fn into_protocols_handler(self) -> TProtoHandler {
+    pub(crate) fn into_connection_handler(self) -> TConnectionHandler {
         self.handler
     }
 }
@@ -224,22 +224,22 @@ where
     }
 }
 
-pub type OutboundOpenInfo<TProtoHandler> = (
+pub type OutboundOpenInfo<TConnectionHandler> = (
     u64,
-    <TProtoHandler as ConnectionHandler>::OutboundOpenInfo,
+    <TConnectionHandler as ConnectionHandler>::OutboundOpenInfo,
     Duration,
 );
 
-impl<TProtoHandler> HandlerWrapper<TProtoHandler>
+impl<TConnectionHandler> HandlerWrapper<TConnectionHandler>
 where
-    TProtoHandler: ConnectionHandler,
+    TConnectionHandler: ConnectionHandler,
 {
     pub fn inject_substream(
         &mut self,
         substream: Substream<StreamMuxerBox>,
         // The first element of the tuple is the unique upgrade identifier
         // (see `unique_dial_upgrade_id`).
-        endpoint: SubstreamEndpoint<OutboundOpenInfo<TProtoHandler>>,
+        endpoint: SubstreamEndpoint<OutboundOpenInfo<TConnectionHandler>>,
     ) {
         match endpoint {
             SubstreamEndpoint::Listener => {
@@ -290,7 +290,7 @@ where
         }
     }
 
-    pub fn inject_event(&mut self, event: TProtoHandler::InEvent) {
+    pub fn inject_event(&mut self, event: TConnectionHandler::InEvent) {
         self.handler.inject_event(event);
     }
 
@@ -303,8 +303,8 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<
         Result<
-            Event<OutboundOpenInfo<TProtoHandler>, TProtoHandler::OutEvent>,
-            Error<TProtoHandler::Error>,
+            Event<OutboundOpenInfo<TConnectionHandler>, TConnectionHandler::OutEvent>,
+            Error<TConnectionHandler::Error>,
         >,
     > {
         while let Poll::Ready(Some((user_data, res))) = self.negotiating_in.poll_next_unpin(cx) {

swarm/src/handler/map_in.rs

@@ -27,15 +27,15 @@ use libp2p_core::Multiaddr;
 use std::{fmt::Debug, marker::PhantomData, task::Context, task::Poll};
 
 /// Wrapper around a protocol handler that turns the input event into something else.
-pub struct MapInEvent<TProtoHandler, TNewIn, TMap> {
-    inner: TProtoHandler,
+pub struct MapInEvent<TConnectionHandler, TNewIn, TMap> {
+    inner: TConnectionHandler,
     map: TMap,
     marker: PhantomData<TNewIn>,
 }
 
-impl<TProtoHandler, TMap, TNewIn> MapInEvent<TProtoHandler, TNewIn, TMap> {
+impl<TConnectionHandler, TMap, TNewIn> MapInEvent<TConnectionHandler, TNewIn, TMap> {
     /// Creates a `MapInEvent`.
-    pub(crate) fn new(inner: TProtoHandler, map: TMap) -> Self {
+    pub(crate) fn new(inner: TConnectionHandler, map: TMap) -> Self {
         MapInEvent {
             inner,
             map,
@@ -44,20 +44,21 @@ impl<TProtoHandler, TMap, TNewIn> MapInEvent<TProtoHandler, TNewIn, TMap> {
     }
 }
 
-impl<TProtoHandler, TMap, TNewIn> ConnectionHandler for MapInEvent<TProtoHandler, TNewIn, TMap>
+impl<TConnectionHandler, TMap, TNewIn> ConnectionHandler
+    for MapInEvent<TConnectionHandler, TNewIn, TMap>
 where
-    TProtoHandler: ConnectionHandler,
-    TMap: Fn(TNewIn) -> Option<TProtoHandler::InEvent>,
+    TConnectionHandler: ConnectionHandler,
+    TMap: Fn(TNewIn) -> Option<TConnectionHandler::InEvent>,
     TNewIn: Debug + Send + 'static,
     TMap: Send + 'static,
 {
     type InEvent = TNewIn;
-    type OutEvent = TProtoHandler::OutEvent;
-    type Error = TProtoHandler::Error;
-    type InboundProtocol = TProtoHandler::InboundProtocol;
-    type OutboundProtocol = TProtoHandler::OutboundProtocol;
-    type InboundOpenInfo = TProtoHandler::InboundOpenInfo;
-    type OutboundOpenInfo = TProtoHandler::OutboundOpenInfo;
+    type OutEvent = TConnectionHandler::OutEvent;
+    type Error = TConnectionHandler::Error;
+    type InboundProtocol = TConnectionHandler::InboundProtocol;
+    type OutboundProtocol = TConnectionHandler::OutboundProtocol;
+    type InboundOpenInfo = TConnectionHandler::InboundOpenInfo;
+    type OutboundOpenInfo = TConnectionHandler::OutboundOpenInfo;
 
     fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol, Self::InboundOpenInfo> {
         self.inner.listen_protocol()

swarm/src/handler/map_out.rs

@@ -28,32 +28,32 @@ use std::fmt::Debug;
 use std::task::{Context, Poll};
 
 /// Wrapper around a protocol handler that turns the output event into something else.
-pub struct MapOutEvent<TProtoHandler, TMap> {
-    inner: TProtoHandler,
+pub struct MapOutEvent<TConnectionHandler, TMap> {
+    inner: TConnectionHandler,
     map: TMap,
 }
 
-impl<TProtoHandler, TMap> MapOutEvent<TProtoHandler, TMap> {
+impl<TConnectionHandler, TMap> MapOutEvent<TConnectionHandler, TMap> {
     /// Creates a `MapOutEvent`.
-    pub(crate) fn new(inner: TProtoHandler, map: TMap) -> Self {
+    pub(crate) fn new(inner: TConnectionHandler, map: TMap) -> Self {
         MapOutEvent { inner, map }
     }
 }
 
-impl<TProtoHandler, TMap, TNewOut> ConnectionHandler for MapOutEvent<TProtoHandler, TMap>
+impl<TConnectionHandler, TMap, TNewOut> ConnectionHandler for MapOutEvent<TConnectionHandler, TMap>
 where
-    TProtoHandler: ConnectionHandler,
-    TMap: FnMut(TProtoHandler::OutEvent) -> TNewOut,
+    TConnectionHandler: ConnectionHandler,
+    TMap: FnMut(TConnectionHandler::OutEvent) -> TNewOut,
     TNewOut: Debug + Send + 'static,
     TMap: Send + 'static,
 {
-    type InEvent = TProtoHandler::InEvent;
+    type InEvent = TConnectionHandler::InEvent;
     type OutEvent = TNewOut;
-    type Error = TProtoHandler::Error;
-    type InboundProtocol = TProtoHandler::InboundProtocol;
-    type OutboundProtocol = TProtoHandler::OutboundProtocol;
-    type InboundOpenInfo = TProtoHandler::InboundOpenInfo;
-    type OutboundOpenInfo = TProtoHandler::OutboundOpenInfo;
+    type Error = TConnectionHandler::Error;
+    type InboundProtocol = TConnectionHandler::InboundProtocol;
+    type OutboundProtocol = TConnectionHandler::OutboundProtocol;
+    type InboundOpenInfo = TConnectionHandler::InboundOpenInfo;
+    type OutboundOpenInfo = TConnectionHandler::OutboundOpenInfo;
 
     fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol, Self::InboundOpenInfo> {
         self.inner.listen_protocol()