feat(swarm): rename NetworkBehaviourAction to ToSwarm

Resolves #3123.

Pull-Request: #3658.

protocols/rendezvous/src/client.rs

@@ -33,8 +33,7 @@ use libp2p_identity::{Keypair, PeerId, SigningError};
 use libp2p_swarm::behaviour::FromSwarm;
 use libp2p_swarm::{
     CloseConnection, ConnectionDenied, ConnectionId, ExternalAddresses, NetworkBehaviour,
-    NetworkBehaviourAction, NotifyHandler, PollParameters, THandler, THandlerInEvent,
-    THandlerOutEvent,
+    NotifyHandler, PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use std::collections::{HashMap, VecDeque};
 use std::iter::FromIterator;
@@ -42,7 +41,7 @@ use std::task::{Context, Poll};
 use void::Void;
 
 pub struct Behaviour {
-    events: VecDeque<NetworkBehaviourAction<Event, InEvent<outbound::OpenInfo, Void, Void>>>,
+    events: VecDeque<ToSwarm<Event, InEvent<outbound::OpenInfo, Void, Void>>>,
     keypair: Keypair,
     pending_register_requests: Vec<(Namespace, PeerId, Option<Ttl>)>,
 
@@ -75,7 +74,7 @@ impl Behaviour {
     /// Register our external addresses in the given namespace with the given rendezvous peer.
     ///
     /// External addresses are either manually added via [`libp2p_swarm::Swarm::add_external_address`] or reported
-    /// by other [`NetworkBehaviour`]s via [`NetworkBehaviourAction::ReportObservedAddr`].
+    /// by other [`NetworkBehaviour`]s via [`ToSwarm::ReportObservedAddr`].
     pub fn register(&mut self, namespace: Namespace, rendezvous_node: PeerId, ttl: Option<Ttl>) {
         self.pending_register_requests
             .push((namespace, rendezvous_node, ttl));
@@ -83,14 +82,13 @@ impl Behaviour {
 
     /// Unregister ourselves from the given namespace with the given rendezvous peer.
     pub fn unregister(&mut self, namespace: Namespace, rendezvous_node: PeerId) {
-        self.events
-            .push_back(NetworkBehaviourAction::NotifyHandler {
-                peer_id: rendezvous_node,
-                event: handler::OutboundInEvent::NewSubstream {
-                    open_info: OpenInfo::UnregisterRequest(namespace),
-                },
-                handler: NotifyHandler::Any,
-            });
+        self.events.push_back(ToSwarm::NotifyHandler {
+            peer_id: rendezvous_node,
+            event: handler::OutboundInEvent::NewSubstream {
+                open_info: OpenInfo::UnregisterRequest(namespace),
+            },
+            handler: NotifyHandler::Any,
+        });
     }
 
     /// Discover other peers at a given rendezvous peer.
@@ -107,18 +105,17 @@ impl Behaviour {
         limit: Option<u64>,
         rendezvous_node: PeerId,
     ) {
-        self.events
-            .push_back(NetworkBehaviourAction::NotifyHandler {
-                peer_id: rendezvous_node,
-                event: handler::OutboundInEvent::NewSubstream {
-                    open_info: OpenInfo::DiscoverRequest {
-                        namespace: ns,
-                        cookie,
-                        limit,
-                    },
+        self.events.push_back(ToSwarm::NotifyHandler {
+            peer_id: rendezvous_node,
+            event: handler::OutboundInEvent::NewSubstream {
+                open_info: OpenInfo::DiscoverRequest {
+                    namespace: ns,
+                    cookie,
+                    limit,
                 },
-                handler: NotifyHandler::Any,
-            });
+            },
+            handler: NotifyHandler::Any,
+        });
     }
 }
 
@@ -233,7 +230,7 @@ impl NetworkBehaviour for Behaviour {
             handler::OutboundOutEvent::OutboundError { error, .. } => {
                 log::warn!("Connection with peer {} failed: {}", peer_id, error);
 
-                vec![NetworkBehaviourAction::CloseConnection {
+                vec![ToSwarm::CloseConnection {
                     peer_id,
                     connection: CloseConnection::One(connection_id),
                 }]
@@ -247,7 +244,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         cx: &mut Context<'_>,
         _: &mut impl PollParameters,
-    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, THandlerInEvent<Self>>> {
+    ) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
         if let Some(event) = self.events.pop_front() {
             return Poll::Ready(event);
         }
@@ -259,13 +256,13 @@ impl NetworkBehaviour for Behaviour {
             let external_addresses = self.external_addresses.iter().cloned().collect::<Vec<_>>();
 
             if external_addresses.is_empty() {
-                return Poll::Ready(NetworkBehaviourAction::GenerateEvent(
-                    Event::RegisterFailed(RegisterError::NoExternalAddresses),
-                ));
+                return Poll::Ready(ToSwarm::GenerateEvent(Event::RegisterFailed(
+                    RegisterError::NoExternalAddresses,
+                )));
             }
 
             let action = match PeerRecord::new(&self.keypair, external_addresses) {
-                Ok(peer_record) => NetworkBehaviourAction::NotifyHandler {
+                Ok(peer_record) => ToSwarm::NotifyHandler {
                     peer_id: rendezvous_node,
                     event: handler::OutboundInEvent::NewSubstream {
                         open_info: OpenInfo::RegisterRequest(NewRegistration {
@@ -276,7 +273,7 @@ impl NetworkBehaviour for Behaviour {
                     },
                     handler: NotifyHandler::Any,
                 },
-                Err(signing_error) => NetworkBehaviourAction::GenerateEvent(Event::RegisterFailed(
+                Err(signing_error) => ToSwarm::GenerateEvent(Event::RegisterFailed(
                     RegisterError::FailedToMakeRecord(signing_error),
                 )),
             };
@@ -288,7 +285,7 @@ impl NetworkBehaviour for Behaviour {
             futures::ready!(self.expiring_registrations.poll_next_unpin(cx))
         {
             self.discovered_peers.remove(&expired_registration);
-            return Poll::Ready(NetworkBehaviourAction::GenerateEvent(Event::Expired {
+            return Poll::Ready(ToSwarm::GenerateEvent(Event::Expired {
                 peer: expired_registration.0,
             }));
         }
@@ -321,23 +318,23 @@ fn handle_outbound_event(
     peer_id: PeerId,
     discovered_peers: &mut HashMap<(PeerId, Namespace), Vec<Multiaddr>>,
     expiring_registrations: &mut FuturesUnordered<BoxFuture<'static, (PeerId, Namespace)>>,
-) -> Vec<NetworkBehaviourAction<Event, THandlerInEvent<Behaviour>>> {
+) -> Vec<ToSwarm<Event, THandlerInEvent<Behaviour>>> {
     match event {
         outbound::OutEvent::Registered { namespace, ttl } => {
-            vec![NetworkBehaviourAction::GenerateEvent(Event::Registered {
+            vec![ToSwarm::GenerateEvent(Event::Registered {
                 rendezvous_node: peer_id,
                 ttl,
                 namespace,
             })]
         }
         outbound::OutEvent::RegisterFailed(namespace, error) => {
-            vec![NetworkBehaviourAction::GenerateEvent(
-                Event::RegisterFailed(RegisterError::Remote {
+            vec![ToSwarm::GenerateEvent(Event::RegisterFailed(
+                RegisterError::Remote {
                     rendezvous_node: peer_id,
                     namespace,
                     error,
-                }),
-            )]
+                },
+            ))]
         }
         outbound::OutEvent::Discovered {
             registrations,
@@ -361,20 +358,18 @@ fn handle_outbound_event(
                 .boxed()
             }));
 
-            vec![NetworkBehaviourAction::GenerateEvent(Event::Discovered {
+            vec![ToSwarm::GenerateEvent(Event::Discovered {
                 rendezvous_node: peer_id,
                 registrations,
                 cookie,
             })]
         }
         outbound::OutEvent::DiscoverFailed { namespace, error } => {
-            vec![NetworkBehaviourAction::GenerateEvent(
-                Event::DiscoverFailed {
-                    rendezvous_node: peer_id,
-                    namespace,
-                    error,
-                },
-            )]
+            vec![ToSwarm::GenerateEvent(Event::DiscoverFailed {
+                rendezvous_node: peer_id,
+                namespace,
+                error,
+            })]
         }
     }
 }

protocols/rendezvous/src/server.rs

@@ -31,8 +31,8 @@ use libp2p_core::{Endpoint, Multiaddr};
 use libp2p_identity::PeerId;
 use libp2p_swarm::behaviour::FromSwarm;
 use libp2p_swarm::{
-    CloseConnection, ConnectionDenied, ConnectionId, NetworkBehaviour, NetworkBehaviourAction,
-    NotifyHandler, PollParameters, THandler, THandlerInEvent, THandlerOutEvent,
+    CloseConnection, ConnectionDenied, ConnectionId, NetworkBehaviour, NotifyHandler,
+    PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::iter::FromIterator;
@@ -41,7 +41,7 @@ use std::time::Duration;
 use void::Void;
 
 pub struct Behaviour {
-    events: VecDeque<NetworkBehaviourAction<Event, InEvent<(), inbound::InEvent, Void>>>,
+    events: VecDeque<ToSwarm<Event, InEvent<(), inbound::InEvent, Void>>>,
     registrations: Registrations,
 }
 
@@ -150,7 +150,7 @@ impl NetworkBehaviour for Behaviour {
             handler::InboundOutEvent::InboundError { error, .. } => {
                 log::warn!("Connection with peer {} failed: {}", peer_id, error);
 
-                vec![NetworkBehaviourAction::CloseConnection {
+                vec![ToSwarm::CloseConnection {
                     peer_id,
                     connection: CloseConnection::One(connection),
                 }]
@@ -165,11 +165,11 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         cx: &mut Context<'_>,
         _: &mut impl PollParameters,
-    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, THandlerInEvent<Self>>> {
+    ) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
         if let Poll::Ready(ExpiredRegistration(registration)) = self.registrations.poll(cx) {
-            return Poll::Ready(NetworkBehaviourAction::GenerateEvent(
-                Event::RegistrationExpired(registration),
-            ));
+            return Poll::Ready(ToSwarm::GenerateEvent(Event::RegistrationExpired(
+                registration,
+            )));
         }
 
         if let Some(event) = self.events.pop_front() {
@@ -203,7 +203,7 @@ fn handle_inbound_event(
     connection: ConnectionId,
     id: InboundSubstreamId,
     registrations: &mut Registrations,
-) -> Vec<NetworkBehaviourAction<Event, THandlerInEvent<Behaviour>>> {
+) -> Vec<ToSwarm<Event, THandlerInEvent<Behaviour>>> {
     match event {
         // bad registration
         inbound::OutEvent::RegistrationRequested(registration)
@@ -212,7 +212,7 @@ fn handle_inbound_event(
             let error = ErrorCode::NotAuthorized;
 
             vec![
-                NetworkBehaviourAction::NotifyHandler {
+                ToSwarm::NotifyHandler {
                     peer_id,
                     handler: NotifyHandler::One(connection),
                     event: handler::InboundInEvent::NotifyInboundSubstream {
@@ -220,7 +220,7 @@ fn handle_inbound_event(
                         message: inbound::InEvent::DeclineRegisterRequest(error),
                     },
                 },
-                NetworkBehaviourAction::GenerateEvent(Event::PeerNotRegistered {
+                ToSwarm::GenerateEvent(Event::PeerNotRegistered {
                     peer: peer_id,
                     namespace: registration.namespace,
                     error,
@@ -233,7 +233,7 @@ fn handle_inbound_event(
             match registrations.add(registration) {
                 Ok(registration) => {
                     vec![
-                        NetworkBehaviourAction::NotifyHandler {
+                        ToSwarm::NotifyHandler {
                             peer_id,
                             handler: NotifyHandler::One(connection),
                             event: handler::InboundInEvent::NotifyInboundSubstream {
@@ -243,7 +243,7 @@ fn handle_inbound_event(
                                 },
                             },
                         },
-                        NetworkBehaviourAction::GenerateEvent(Event::PeerRegistered {
+                        ToSwarm::GenerateEvent(Event::PeerRegistered {
                             peer: peer_id,
                             registration,
                         }),
@@ -253,7 +253,7 @@ fn handle_inbound_event(
                     let error = ErrorCode::InvalidTtl;
 
                     vec![
-                        NetworkBehaviourAction::NotifyHandler {
+                        ToSwarm::NotifyHandler {
                             peer_id,
                             handler: NotifyHandler::One(connection),
                             event: handler::InboundInEvent::NotifyInboundSubstream {
@@ -261,7 +261,7 @@ fn handle_inbound_event(
                                 message: inbound::InEvent::DeclineRegisterRequest(error),
                             },
                         },
-                        NetworkBehaviourAction::GenerateEvent(Event::PeerNotRegistered {
+                        ToSwarm::GenerateEvent(Event::PeerNotRegistered {
                             peer: peer_id,
                             namespace,
                             error,
@@ -279,7 +279,7 @@ fn handle_inbound_event(
                 let discovered = registrations.cloned().collect::<Vec<_>>();
 
                 vec![
-                    NetworkBehaviourAction::NotifyHandler {
+                    ToSwarm::NotifyHandler {
                         peer_id,
                         handler: NotifyHandler::One(connection),
                         event: handler::InboundInEvent::NotifyInboundSubstream {
@@ -290,7 +290,7 @@ fn handle_inbound_event(
                             },
                         },
                     },
-                    NetworkBehaviourAction::GenerateEvent(Event::DiscoverServed {
+                    ToSwarm::GenerateEvent(Event::DiscoverServed {
                         enquirer: peer_id,
                         registrations: discovered,
                     }),
@@ -300,7 +300,7 @@ fn handle_inbound_event(
                 let error = ErrorCode::InvalidCookie;
 
                 vec![
-                    NetworkBehaviourAction::NotifyHandler {
+                    ToSwarm::NotifyHandler {
                         peer_id,
                         handler: NotifyHandler::One(connection),
                         event: handler::InboundInEvent::NotifyInboundSubstream {
@@ -308,7 +308,7 @@ fn handle_inbound_event(
                             message: inbound::InEvent::DeclineDiscoverRequest(error),
                         },
                     },
-                    NetworkBehaviourAction::GenerateEvent(Event::DiscoverNotServed {
+                    ToSwarm::GenerateEvent(Event::DiscoverNotServed {
                         enquirer: peer_id,
                         error,
                     }),
@@ -318,12 +318,10 @@ fn handle_inbound_event(
         inbound::OutEvent::UnregisterRequested(namespace) => {
             registrations.remove(namespace.clone(), peer_id);
 
-            vec![NetworkBehaviourAction::GenerateEvent(
-                Event::PeerUnregistered {
-                    peer: peer_id,
-                    namespace,
-                },
-            )]
+            vec![ToSwarm::GenerateEvent(Event::PeerUnregistered {
+                peer: peer_id,
+                namespace,
+            })]
         }
     }
 }