refactor(swarm)!: deprecate PollParameters where possible (#3153)

This patch deprecates 3 out of 4 functions on `PollParameters`:

- `local_peer_id`
- `listened_addresses`
- `external_addresses`

The addresses can be obtained by inspecting the `FromSwarm` event. To make this easier, we introduce two utility structs in `libp2p-swarm`:

- `ExternalAddresses`
- `ListenAddresses`

A node's `PeerId` is always known to the caller, thus we can require them to pass it in.

Related: #3124.

Author: thomaseizinger

examples/chat-tokio.rs

@@ -91,7 +91,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     }
 
     // Create a Swarm to manage peers and events.
-    let mdns_behaviour = mdns::Behaviour::new(Default::default())?;
+    let mdns_behaviour = mdns::Behaviour::new(Default::default(), peer_id)?;
     let behaviour = MyBehaviour {
         floodsub: Floodsub::new(peer_id),
         mdns: mdns_behaviour,

examples/chat.rs

@@ -107,7 +107,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Create a Swarm to manage peers and events
     let mut swarm = {
-        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default())?;
+        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default(), local_peer_id)?;
         let mut behaviour = MyBehaviour {
             floodsub: Floodsub::new(local_peer_id),
             mdns,

examples/distributed-key-value-store.rs

@@ -97,7 +97,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         // Create a Kademlia behaviour.
         let store = MemoryStore::new(local_peer_id);
         let kademlia = Kademlia::new(local_peer_id, store);
-        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default())?;
+        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default(), local_peer_id)?;
         let behaviour = MyBehaviour { kademlia, mdns };
         Swarm::with_async_std_executor(transport, behaviour, local_peer_id)
     };

examples/gossipsub-chat.rs

@@ -104,7 +104,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Create a Swarm to manage peers and events
     let mut swarm = {
-        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default())?;
+        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default(), local_peer_id)?;
         let behaviour = MyBehaviour { gossipsub, mdns };
         Swarm::with_async_std_executor(transport, behaviour, local_peer_id)
     };

examples/mdns-passive-discovery.rs

@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let transport = libp2p::development_transport(id_keys).await?;
 
     // Create an MDNS network behaviour.
-    let behaviour = mdns::async_io::Behaviour::new(mdns::Config::default())?;
+    let behaviour = mdns::async_io::Behaviour::new(mdns::Config::default(), peer_id)?;
 
     // Create a Swarm that establishes connections through the given transport.
     // Note that the MDNS behaviour itself will not actually inititiate any connections,

protocols/autonat/CHANGELOG.md

@@ -1,9 +1,13 @@
 # 0.10.0 [unreleased]
 
+- Require the node's local `PeerId` to be passed into the constructor of `libp2p_autonat::Behaviour`. See [PR 3153].
+
 - Update to `libp2p-request-response` `v0.24.0`.
 
 - Update to `libp2p-swarm` `v0.42.0`.
 
+[PR 3153]: https://github.com/libp2p/rust-libp2p/pull/3153
+
 # 0.9.0
 
 - Update to `libp2p-core` `v0.38.0`.

protocols/autonat/src/behaviour.rs

@@ -39,8 +39,8 @@ use libp2p_swarm::{
         AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, ExpiredExternalAddr,
         ExpiredListenAddr, FromSwarm,
     },
-    ConnectionHandler, IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction,
-    PollParameters,
+    ConnectionHandler, ExternalAddresses, IntoConnectionHandler, ListenAddresses, NetworkBehaviour,
+    NetworkBehaviourAction, PollParameters,
 };
 use std::{
     collections::{HashMap, VecDeque},
@@ -212,6 +212,9 @@ pub struct Behaviour {
     pending_out_events: VecDeque<<Self as NetworkBehaviour>::OutEvent>,
 
     probe_id: ProbeId,
+
+    listen_addresses: ListenAddresses,
+    external_addresses: ExternalAddresses,
 }
 
 impl Behaviour {
@@ -236,6 +239,8 @@ impl Behaviour {
             last_probe: None,
             pending_out_events: VecDeque::new(),
             probe_id: ProbeId(0),
+            listen_addresses: Default::default(),
+            external_addresses: Default::default(),
         }
     }
 
@@ -288,6 +293,8 @@ impl Behaviour {
             ongoing_outbound: &mut self.ongoing_outbound,
             last_probe: &mut self.last_probe,
             schedule_probe: &mut self.schedule_probe,
+            listen_addresses: &self.listen_addresses,
+            external_addresses: &self.external_addresses,
         }
     }
 
@@ -457,7 +464,7 @@ impl NetworkBehaviour for Behaviour {
                 Poll::Pending => is_inner_pending = true,
             }
 
-            match self.as_client().poll_auto_probe(params, cx) {
+            match self.as_client().poll_auto_probe(cx) {
                 Poll::Ready(event) => self
                     .pending_out_events
                     .push_back(Event::OutboundProbe(event)),
@@ -476,6 +483,9 @@ impl NetworkBehaviour for Behaviour {
     }
 
     fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+        self.listen_addresses.on_swarm_event(&event);
+        self.external_addresses.on_swarn_event(&event);
+
         match event {
             FromSwarm::ConnectionEstablished(connection_established) => {
                 self.inner

protocols/autonat/src/behaviour/as_client.rs

@@ -29,7 +29,9 @@ use futures_timer::Delay;
 use instant::Instant;
 use libp2p_core::{connection::ConnectionId, Multiaddr, PeerId};
 use libp2p_request_response::{self as request_response, OutboundFailure, RequestId};
-use libp2p_swarm::{AddressScore, NetworkBehaviourAction, PollParameters};
+use libp2p_swarm::{
+    AddressScore, ExternalAddresses, ListenAddresses, NetworkBehaviourAction, PollParameters,
+};
 use rand::{seq::SliceRandom, thread_rng};
 use std::{
     collections::{HashMap, VecDeque},
@@ -97,6 +99,9 @@ pub struct AsClient<'a> {
 
     pub last_probe: &'a mut Option<Instant>,
     pub schedule_probe: &'a mut Delay,
+
+    pub listen_addresses: &'a ListenAddresses,
+    pub external_addresses: &'a ExternalAddresses,
 }
 
 impl<'a> HandleInnerEvent for AsClient<'a> {
@@ -146,6 +151,8 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
 
                 if let Ok(address) = response.result {
                     // Update observed address score if it is finite.
+                    #[allow(deprecated)]
+                    // TODO: Fix once we report `AddressScore` through `FromSwarm` event.
                     let score = params
                         .external_addresses()
                         .find_map(|r| (r.addr == address).then_some(r.score))
@@ -188,17 +195,17 @@ impl<'a> HandleInnerEvent for AsClient<'a> {
 }
 
 impl<'a> AsClient<'a> {
-    pub fn poll_auto_probe(
-        &mut self,
-        params: &mut impl PollParameters,
-        cx: &mut Context<'_>,
-    ) -> Poll<OutboundProbeEvent> {
+    pub fn poll_auto_probe(&mut self, cx: &mut Context<'_>) -> Poll<OutboundProbeEvent> {
         match self.schedule_probe.poll_unpin(cx) {
             Poll::Ready(()) => {
                 self.schedule_probe.reset(self.config.retry_interval);
 
-                let mut addresses: Vec<_> = params.external_addresses().map(|r| r.addr).collect();
-                addresses.extend(params.listened_addresses());
+                let addresses = self
+                    .external_addresses
+                    .iter()
+                    .chain(self.listen_addresses.iter())
+                    .cloned()
+                    .collect();
 
                 let probe_id = self.probe_id.next();
                 let event = match self.do_probe(probe_id, addresses) {

protocols/dcutr/CHANGELOG.md

@@ -5,7 +5,10 @@
 - Declare `InboundUpgradeError` and `OutboundUpgradeError` as type aliases instead of renames.
   This is a workaround for a missing feature in `cargo semver-checks`. See [PR 3213].
 
+- Require the node's local `PeerId` to be passed into the constructor of `libp2p_dcutr::Behaviour`. See [PR 3153].
+
 [PR 3213]: https://github.com/libp2p/rust-libp2p/pull/3213
+[PR 3153]: https://github.com/libp2p/rust-libp2p/pull/3153
 
 # 0.8.0
 

protocols/dcutr/examples/dcutr.rs

@@ -157,7 +157,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             "/TODO/0.0.1".to_string(),
             local_key.public(),
         )),
-        dcutr: dcutr::behaviour::Behaviour::new(),
+        dcutr: dcutr::behaviour::Behaviour::new(local_peer_id),
     };
 
     let mut swarm = match ThreadPool::new() {

protocols/dcutr/src/behaviour.rs

@@ -29,8 +29,8 @@ use libp2p_core::{Multiaddr, PeerId};
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
 use libp2p_swarm::dial_opts::{self, DialOpts};
 use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerUpgrErr, IntoConnectionHandler, NetworkBehaviour,
-    NetworkBehaviourAction, NotifyHandler, PollParameters,
+    ConnectionHandler, ConnectionHandlerUpgrErr, ExternalAddresses, IntoConnectionHandler,
+    NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::task::{Context, Poll};
@@ -66,20 +66,25 @@ pub enum UpgradeError {
     Handler(ConnectionHandlerUpgrErr<void::Void>),
 }
 
-#[derive(Default)]
 pub struct Behaviour {
     /// Queue of actions to return when polled.
     queued_actions: VecDeque<ActionBuilder>,
 
     /// All direct (non-relayed) connections.
     direct_connections: HashMap<PeerId, HashSet<ConnectionId>>,
+
+    external_addresses: ExternalAddresses,
+
+    local_peer_id: PeerId,
 }
 
 impl Behaviour {
-    pub fn new() -> Self {
+    pub fn new(local_peer_id: PeerId) -> Self {
         Behaviour {
             queued_actions: Default::default(),
             direct_connections: Default::default(),
+            external_addresses: Default::default(),
+            local_peer_id,
         }
     }
 
@@ -308,16 +313,18 @@ impl NetworkBehaviour for Behaviour {
     fn poll(
         &mut self,
         _cx: &mut Context<'_>,
-        poll_parameters: &mut impl PollParameters,
+        _: &mut impl PollParameters,
     ) -> Poll<NetworkBehaviourAction<Self::OutEvent, Self::ConnectionHandler>> {
         if let Some(action) = self.queued_actions.pop_front() {
-            return Poll::Ready(action.build(poll_parameters));
+            return Poll::Ready(action.build(self.local_peer_id, &self.external_addresses));
         }
 
         Poll::Pending
     }
 
     fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+        self.external_addresses.on_swarn_event(&event);
+
         match event {
             FromSwarm::ConnectionEstablished(connection_established) => {
                 self.on_connection_established(connection_established)
@@ -364,16 +371,15 @@ impl From<NetworkBehaviourAction<Event, handler::Prototype>> for ActionBuilder {
 impl ActionBuilder {
     fn build(
         self,
-        poll_parameters: &mut impl PollParameters,
+        local_peer_id: PeerId,
+        external_addresses: &ExternalAddresses,
     ) -> NetworkBehaviourAction<Event, handler::Prototype> {
         let obs_addrs = || {
-            poll_parameters
-                .external_addresses()
-                .filter(|a| !a.addr.iter().any(|p| p == Protocol::P2pCircuit))
-                .map(|a| {
-                    a.addr
-                        .with(Protocol::P2p((*poll_parameters.local_peer_id()).into()))
-                })
+            external_addresses
+                .iter()
+                .cloned()
+                .filter(|a| !a.iter().any(|p| p == Protocol::P2pCircuit))
+                .map(|a| a.with(Protocol::P2p(local_peer_id.into())))
                 .collect()
         };
 

protocols/dcutr/tests/lib.rs

@@ -126,7 +126,7 @@ fn build_client() -> Swarm<Client> {
         transport,
         Client {
             relay: behaviour,
-            dcutr: dcutr::behaviour::Behaviour::new(),
+            dcutr: dcutr::behaviour::Behaviour::new(local_peer_id),
         },
         local_peer_id,
     )

protocols/identify/src/behaviour.rs

@@ -26,7 +26,8 @@ use libp2p_core::{
 use libp2p_swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
 use libp2p_swarm::{
     dial_opts::DialOpts, AddressScore, ConnectionHandler, ConnectionHandlerUpgrErr, DialError,
-    IntoConnectionHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler, PollParameters,
+    ExternalAddresses, IntoConnectionHandler, ListenAddresses, NetworkBehaviour,
+    NetworkBehaviourAction, NotifyHandler, PollParameters,
 };
 use lru::LruCache;
 use std::num::NonZeroUsize;
@@ -56,6 +57,9 @@ pub struct Behaviour {
     events: VecDeque<NetworkBehaviourAction<Event, Proto>>,
     /// The addresses of all peers that we have discovered.
     discovered_peers: PeerCache,
+
+    listen_addresses: ListenAddresses,
+    external_addresses: ExternalAddresses,
 }
 
 /// A `Behaviour` request to be fulfilled, either `Handler` requests for `Behaviour` info
@@ -177,6 +181,8 @@ impl Behaviour {
             requests: Vec::new(),
             events: VecDeque::new(),
             discovered_peers,
+            listen_addresses: Default::default(),
+            external_addresses: Default::default(),
         }
     }
 
@@ -318,7 +324,12 @@ impl NetworkBehaviour for Behaviour {
                 peer_id,
                 handler: NotifyHandler::Any,
                 event: InEvent {
-                    listen_addrs: listen_addrs(params),
+                    listen_addrs: self
+                        .listen_addresses
+                        .iter()
+                        .chain(self.external_addresses.iter())
+                        .cloned()
+                        .collect(),
                     supported_protocols: supported_protocols(params),
                     protocol: Protocol::Push,
                 },
@@ -330,7 +341,12 @@ impl NetworkBehaviour for Behaviour {
                 peer_id,
                 handler: NotifyHandler::One(connection_id),
                 event: InEvent {
-                    listen_addrs: listen_addrs(params),
+                    listen_addrs: self
+                        .listen_addresses
+                        .iter()
+                        .chain(self.external_addresses.iter())
+                        .cloned()
+                        .collect(),
                     supported_protocols: supported_protocols(params),
                     protocol: Protocol::Identify(connection_id),
                 },
@@ -344,6 +360,9 @@ impl NetworkBehaviour for Behaviour {
     }
 
     fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+        self.listen_addresses.on_swarm_event(&event);
+        self.external_addresses.on_swarn_event(&event);
+
         match event {
             FromSwarm::ConnectionEstablished(connection_established) => {
                 self.on_connection_established(connection_established)
@@ -453,12 +472,6 @@ fn supported_protocols(params: &impl PollParameters) -> Vec<String> {
         .collect()
 }
 
-fn listen_addrs(params: &impl PollParameters) -> Vec<Multiaddr> {
-    let mut listen_addrs: Vec<_> = params.external_addresses().map(|r| r.addr).collect();
-    listen_addrs.extend(params.listened_addresses());
-    listen_addrs
-}
-
 /// If there is a given peer_id in the multiaddr, make sure it is the same as
 /// the given peer_id. If there is no peer_id for the peer in the mutiaddr, this returns true.
 fn multiaddr_matches_peer_id(addr: &Multiaddr, peer_id: &PeerId) -> bool {