feat(swarm): rename NetworkBehaviourAction to ToSwarm

Resolves #3123.

Pull-Request: #3658.

Author: thomaseizinger

docs/coding-guidelines.md

@@ -310,7 +310,7 @@ request without having to guess.
 
 When accepting a **command** that eventually results in a response through an event require that
 command to contain a unique ID, which is later on contained in the asynchronous response event. One
-such example is the `Swarm` accepting a `NetworkBehaviourAction::Dial` from the `NetworkBehaviour`.
+such example is the `Swarm` accepting a `ToSwarm::Dial` from the `NetworkBehaviour`.
 
 ``` rust
 struct Command {

misc/allow-block-list/src/lib.rs

@@ -65,7 +65,7 @@ use libp2p_core::{Endpoint, Multiaddr};
 use libp2p_identity::PeerId;
 use libp2p_swarm::{
     dummy, CloseConnection, ConnectionDenied, ConnectionId, FromSwarm, NetworkBehaviour,
-    NetworkBehaviourAction, PollParameters, THandler, THandlerInEvent, THandlerOutEvent,
+    PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use std::collections::{HashSet, VecDeque};
 use std::fmt;
@@ -261,9 +261,9 @@ where
         &mut self,
         cx: &mut Context<'_>,
         _: &mut impl PollParameters,
-    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, THandlerInEvent<Self>>> {
+    ) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
         if let Some(peer) = self.close_connections.pop_front() {
-            return Poll::Ready(NetworkBehaviourAction::CloseConnection {
+            return Poll::Ready(ToSwarm::CloseConnection {
                 peer_id: peer,
                 connection: CloseConnection::All,
             });

misc/connection-limits/src/lib.rs

@@ -22,7 +22,7 @@ use libp2p_core::{Endpoint, Multiaddr};
 use libp2p_identity::PeerId;
 use libp2p_swarm::{
     dummy, ConnectionClosed, ConnectionDenied, ConnectionId, FromSwarm, NetworkBehaviour,
-    NetworkBehaviourAction, PollParameters, THandler, THandlerInEvent, THandlerOutEvent,
+    PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -355,7 +355,7 @@ impl NetworkBehaviour for Behaviour {
         &mut self,
         _: &mut Context<'_>,
         _: &mut impl PollParameters,
-    ) -> Poll<NetworkBehaviourAction<Self::OutEvent, THandlerInEvent<Self>>> {
+    ) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
         Poll::Pending
     }
 }

protocols/autonat/src/behaviour.rs

@@ -39,7 +39,7 @@ use libp2p_swarm::{
         ExpiredListenAddr, FromSwarm,
     },
     ConnectionDenied, ConnectionId, ExternalAddresses, ListenAddresses, NetworkBehaviour,
-    NetworkBehaviourAction, PollParameters, THandler, THandlerInEvent, THandlerOutEvent,
+    PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use std::{
     collections::{HashMap, VecDeque},
@@ -208,9 +208,7 @@ pub struct Behaviour {
 
     last_probe: Option<Instant>,
 
-    pending_actions: VecDeque<
-        NetworkBehaviourAction<<Self as NetworkBehaviour>::OutEvent, THandlerInEvent<Self>>,
-    >,
+    pending_actions: VecDeque<ToSwarm<<Self as NetworkBehaviour>::OutEvent, THandlerInEvent<Self>>>,
 
     probe_id: ProbeId,
 
@@ -336,9 +334,7 @@ impl Behaviour {
             } => {
                 if let Some(event) = self.as_server().on_outbound_connection(&peer, address) {
                     self.pending_actions
-                        .push_back(NetworkBehaviourAction::GenerateEvent(Event::InboundProbe(
-                            event,
-                        )));
+                        .push_back(ToSwarm::GenerateEvent(Event::InboundProbe(event)));
                 }
             }
             ConnectedPoint::Dialer {
@@ -399,9 +395,7 @@ impl Behaviour {
             }));
         if let Some(event) = self.as_server().on_outbound_dial_error(peer_id, error) {
             self.pending_actions
-                .push_back(NetworkBehaviourAction::GenerateEvent(Event::InboundProbe(
-                    event,
-                )));
+                .push_back(ToSwarm::GenerateEvent(Event::InboundProbe(event)));
         }
     }
 
@@ -441,7 +435,7 @@ impl NetworkBehaviour for Behaviour {
             }
 
             match self.inner.poll(cx, params) {
-                Poll::Ready(NetworkBehaviourAction::GenerateEvent(event)) => {
+                Poll::Ready(ToSwarm::GenerateEvent(event)) => {
                     let actions = match event {
                         request_response::Event::Message {
                             message: request_response::Message::Response { .. },
@@ -474,9 +468,7 @@ impl NetworkBehaviour for Behaviour {
             match self.as_client().poll_auto_probe(cx) {
                 Poll::Ready(event) => {
                     self.pending_actions
-                        .push_back(NetworkBehaviourAction::GenerateEvent(Event::OutboundProbe(
-                            event,
-                        )));
+                        .push_back(ToSwarm::GenerateEvent(Event::OutboundProbe(event)));
                     continue;
                 }
                 Poll::Pending => {}
@@ -601,8 +593,7 @@ impl NetworkBehaviour for Behaviour {
     }
 }
 
-type Action =
-    NetworkBehaviourAction<<Behaviour as NetworkBehaviour>::OutEvent, THandlerInEvent<Behaviour>>;
+type Action = ToSwarm<<Behaviour as NetworkBehaviour>::OutEvent, THandlerInEvent<Behaviour>>;
 
 // Trait implemented for `AsClient` and `AsServer` to handle events from the inner [`request_response::Behaviour`] Protocol.
 trait HandleInnerEvent {

protocols/autonat/src/behaviour/as_client.rs

@@ -31,8 +31,7 @@ use libp2p_core::Multiaddr;
 use libp2p_identity::PeerId;
 use libp2p_request_response::{self as request_response, OutboundFailure, RequestId};
 use libp2p_swarm::{
-    AddressScore, ConnectionId, ExternalAddresses, ListenAddresses, NetworkBehaviourAction,
-    PollParameters,
+    AddressScore, ConnectionId, ExternalAddresses, ListenAddresses, PollParameters, ToSwarm,
 };
 use rand::{seq::SliceRandom, thread_rng};
 use std::{
@@ -143,17 +142,13 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
 
                 let mut actions = VecDeque::with_capacity(3);
 
-                actions.push_back(NetworkBehaviourAction::GenerateEvent(Event::OutboundProbe(
-                    event,
-                )));
+                actions.push_back(ToSwarm::GenerateEvent(Event::OutboundProbe(event)));
 
                 if let Some(old) = self.handle_reported_status(response.result.clone().into()) {
-                    actions.push_back(NetworkBehaviourAction::GenerateEvent(
-                        Event::StatusChanged {
-                            old,
-                            new: self.nat_status.clone(),
-                        },
-                    ));
+                    actions.push_back(ToSwarm::GenerateEvent(Event::StatusChanged {
+                        old,
+                        new: self.nat_status.clone(),
+                    }));
                 }
 
                 if let Ok(address) = response.result {
@@ -165,7 +160,7 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
                         .find_map(|r| (r.addr == address).then_some(r.score))
                         .unwrap_or(AddressScore::Finite(0));
                     if let AddressScore::Finite(finite_score) = score {
-                        actions.push_back(NetworkBehaviourAction::ReportObservedAddr {
+                        actions.push_back(ToSwarm::ReportObservedAddr {
                             address,
                             score: AddressScore::Finite(finite_score + 1),
                         });
@@ -191,7 +186,7 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
 
                 self.schedule_probe.reset(Duration::ZERO);
 
-                VecDeque::from([NetworkBehaviourAction::GenerateEvent(Event::OutboundProbe(
+                VecDeque::from([ToSwarm::GenerateEvent(Event::OutboundProbe(
                     OutboundProbeEvent::Error {
                         probe_id,
                         peer: Some(peer),

protocols/autonat/src/behaviour/as_server.rs

@@ -30,7 +30,7 @@ use libp2p_request_response::{
 };
 use libp2p_swarm::{
     dial_opts::{DialOpts, PeerCondition},
-    ConnectionId, DialError, NetworkBehaviourAction, PollParameters,
+    ConnectionId, DialError, PollParameters, ToSwarm,
 };
 use std::{
     collections::{HashMap, HashSet, VecDeque},
@@ -124,14 +124,14 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                         self.throttled_clients.push((peer, Instant::now()));
 
                         VecDeque::from([
-                            NetworkBehaviourAction::GenerateEvent(Event::InboundProbe(
+                            ToSwarm::GenerateEvent(Event::InboundProbe(
                                 InboundProbeEvent::Request {
                                     probe_id,
                                     peer,
                                     addresses: addrs.clone(),
                                 },
                             )),
-                            NetworkBehaviourAction::Dial {
+                            ToSwarm::Dial {
                                 opts: DialOpts::peer_id(peer)
                                     .condition(PeerCondition::Always)
                                     .override_dial_concurrency_factor(
@@ -155,13 +155,13 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                         };
                         let _ = self.inner.send_response(channel, response);
 
-                        VecDeque::from([NetworkBehaviourAction::GenerateEvent(
-                            Event::InboundProbe(InboundProbeEvent::Error {
+                        VecDeque::from([ToSwarm::GenerateEvent(Event::InboundProbe(
+                            InboundProbeEvent::Error {
                                 probe_id,
                                 peer,
                                 error: InboundProbeError::Response(error),
-                            }),
-                        )])
+                            },
+                        ))])
                     }
                 }
             }
@@ -183,7 +183,7 @@ impl<'a> HandleInnerEvent for AsServer<'a> {
                     _ => self.probe_id.next(),
                 };
 
-                VecDeque::from([NetworkBehaviourAction::GenerateEvent(Event::InboundProbe(
+                VecDeque::from([ToSwarm::GenerateEvent(Event::InboundProbe(
                     InboundProbeEvent::Error {
                         probe_id,
                         peer,