swarm/src/lib: Remove Deref and DerefMut impls on Swarm (#1995)

Remove `Deref` and `DerefMut` implementations previously dereferencing
to the `NetworkBehaviour` on `Swarm`. Instead one can access the
`NetworkBehaviour` via `Swarm::behaviour` and `Swarm::behaviour_mut`.
Methods on `Swarm` can now be accessed directly, e.g. via
`my_swarm.local_peer_id()`.

Reasoning: Accessing the `NetworkBehaviour` of a `Swarm` through `Deref`
and `DerefMut` instead of a method call is an unnecessary complication,
especially for newcomers. In addition, `Swarm` is not a smart-pointer
and should thus not make use of `Deref` and `DerefMut`, see documentation
from the standard library below.

> Deref should only be implemented for smart pointers to avoid
confusion.

https://doc.rust-lang.org/std/ops/trait.Deref.html

Author: mxinden

CHANGELOG.md

@@ -1,4 +1,3 @@
-
 # Individual crates
 
 ## Main APIs
@@ -44,7 +43,15 @@
 
 ## Version 0.37.0 [unreleased]
 
-- Update `libp2p-identify`.
+- Update individual crates.
+    - `libp2p-floodsub`
+    - `libp2p-gossipsub`
+    - `libp2p-kad`
+    - `libp2p-mdns`
+    - `libp2p-ping`
+    - `libp2p-relay`
+    - `libp2p-request-response`
+    - `libp2p-swarm`
 
 ## Version 0.36.0 [2021-03-17]
 

Cargo.toml

@@ -65,18 +65,18 @@ bytes = "1"
 futures = "0.3.1"
 lazy_static = "1.2"
 libp2p-core = { version = "0.28.0", path = "core",  default-features = false }
-libp2p-floodsub = { version = "0.28.0", path = "protocols/floodsub", optional = true }
-libp2p-gossipsub = { version = "0.29.0", path = "./protocols/gossipsub", optional = true }
+libp2p-floodsub = { version = "0.29.0", path = "protocols/floodsub", optional = true }
+libp2p-gossipsub = { version = "0.30.0", path = "./protocols/gossipsub", optional = true }
 libp2p-identify = { version = "0.29.0", path = "protocols/identify", optional = true }
-libp2p-kad = { version = "0.29.0", path = "protocols/kad", optional = true }
+libp2p-kad = { version = "0.30.0", path = "protocols/kad", optional = true }
 libp2p-mplex = { version = "0.28.0", path = "muxers/mplex", optional = true }
 libp2p-noise = { version = "0.30.0", path = "transports/noise", optional = true }
-libp2p-ping = { version = "0.28.0", path = "protocols/ping", optional = true }
+libp2p-ping = { version = "0.29.0", path = "protocols/ping", optional = true }
 libp2p-plaintext = { version = "0.28.0", path = "transports/plaintext", optional = true }
 libp2p-pnet = { version = "0.20.0", path = "transports/pnet", optional = true }
-libp2p-relay = { version = "0.1.0", path = "protocols/relay", optional = true }
-libp2p-request-response = { version = "0.10.0", path = "protocols/request-response", optional = true }
-libp2p-swarm = { version = "0.28.0", path = "swarm" }
+libp2p-relay = { version = "0.2.0", path = "protocols/relay", optional = true }
+libp2p-request-response = { version = "0.11.0", path = "protocols/request-response", optional = true }
+libp2p-swarm = { version = "0.29.0", path = "swarm" }
 libp2p-swarm-derive = { version = "0.22.0", path = "swarm-derive" }
 libp2p-uds = { version = "0.28.0", path = "transports/uds", optional = true }
 libp2p-wasm-ext = { version = "0.28.0", path = "transports/wasm-ext", default-features = false, optional = true }
@@ -90,7 +90,7 @@ wasm-timer = "0.2.4"
 [target.'cfg(not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown")))'.dependencies]
 libp2p-deflate = { version = "0.28.0", path = "transports/deflate", optional = true }
 libp2p-dns = { version = "0.28.0", path = "transports/dns", optional = true, default-features = false }
-libp2p-mdns = { version = "0.29.0", path = "protocols/mdns", optional = true }
+libp2p-mdns = { version = "0.30.0", path = "protocols/mdns", optional = true }
 libp2p-tcp = { version = "0.28.0", path = "transports/tcp", default-features = false, optional = true }
 libp2p-websocket = { version = "0.29.0", path = "transports/websocket", optional = true }
 

examples/chat-tokio.rs

@@ -138,15 +138,15 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Reach out to another node if specified
     if let Some(to_dial) = std::env::args().nth(1) {
         let addr: Multiaddr = to_dial.parse()?;
-        Swarm::dial_addr(&mut swarm, addr)?;
+        swarm.dial_addr(addr)?;
         println!("Dialed {:?}", to_dial)
     }
 
     // Read full lines from stdin
     let mut stdin = io::BufReader::new(io::stdin()).lines();
 
     // Listen on all interfaces and whatever port the OS assigns
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     // Kick it off
     let mut listening = false;
@@ -166,7 +166,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
             }
         };
         if let Some((topic, line)) = to_publish {
-            swarm.floodsub.publish(topic, line.as_bytes());
+            swarm.behaviour_mut().floodsub.publish(topic, line.as_bytes());
         }
         if !listening {
             for addr in Swarm::listeners(&swarm) {

examples/chat.rs

@@ -136,22 +136,24 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Reach out to another node if specified
     if let Some(to_dial) = std::env::args().nth(1) {
         let addr: Multiaddr = to_dial.parse()?;
-        Swarm::dial_addr(&mut swarm, addr)?;
+        swarm.dial_addr(addr)?;
         println!("Dialed {:?}", to_dial)
     }
 
     // Read full lines from stdin
     let mut stdin = io::BufReader::new(io::stdin()).lines();
 
     // Listen on all interfaces and whatever port the OS assigns
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     // Kick it off
     let mut listening = false;
     task::block_on(future::poll_fn(move |cx: &mut Context<'_>| {
         loop {
             match stdin.try_poll_next_unpin(cx)? {
-                Poll::Ready(Some(line)) => swarm.floodsub.publish(floodsub_topic.clone(), line.as_bytes()),
+                Poll::Ready(Some(line)) => swarm.behaviour_mut()
+                    .floodsub
+                    .publish(floodsub_topic.clone(), line.as_bytes()),
                 Poll::Ready(None) => panic!("Stdin closed"),
                 Poll::Pending => break
             }

examples/distributed-key-value-store.rs

@@ -161,14 +161,14 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let mut stdin = io::BufReader::new(io::stdin()).lines();
 
     // Listen on all interfaces and whatever port the OS assigns.
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     // Kick it off.
     let mut listening = false;
     task::block_on(future::poll_fn(move |cx: &mut Context<'_>| {
         loop {
             match stdin.try_poll_next_unpin(cx)? {
-                Poll::Ready(Some(line)) => handle_input_line(&mut swarm.kademlia, line),
+                Poll::Ready(Some(line)) => handle_input_line(&mut swarm.behaviour_mut().kademlia, line),
                 Poll::Ready(None) => panic!("Stdin closed"),
                 Poll::Pending => break
             }

examples/gossipsub-chat.rs

@@ -116,13 +116,13 @@ async fn main() -> Result<(), Box<dyn Error>> {
     };
 
     // Listen on all interfaces and whatever port the OS assigns
-    libp2p::Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
 
     // Reach out to another node if specified
     if let Some(to_dial) = std::env::args().nth(1) {
         let dialing = to_dial.clone();
         match to_dial.parse() {
-            Ok(to_dial) => match libp2p::Swarm::dial_addr(&mut swarm, to_dial) {
+            Ok(to_dial) => match swarm.dial_addr(to_dial) {
                 Ok(_) => println!("Dialed {:?}", dialing),
                 Err(e) => println!("Dial {:?} failed: {:?}", dialing, e),
             },
@@ -138,7 +138,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     task::block_on(future::poll_fn(move |cx: &mut Context<'_>| {
         loop {
             if let Err(e) = match stdin.try_poll_next_unpin(cx)? {
-                Poll::Ready(Some(line)) => swarm.publish(topic.clone(), line.as_bytes()),
+                Poll::Ready(Some(line)) => swarm.behaviour_mut().publish(topic.clone(), line.as_bytes()),
                 Poll::Ready(None) => panic!("Stdin closed"),
                 Poll::Pending => break,
             } {

examples/ipfs-kad.rs

@@ -86,7 +86,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     };
 
     println!("Searching for the closest peers to {:?}", to_search);
-    swarm.get_closest_peers(to_search);
+    swarm.behaviour_mut().get_closest_peers(to_search);
 
     // Kick it off!
     task::block_on(async move {

examples/ipfs-private.rs

@@ -260,22 +260,23 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Reach out to other nodes if specified
     for to_dial in std::env::args().skip(1) {
         let addr: Multiaddr = parse_legacy_multiaddr(&to_dial)?;
-        Swarm::dial_addr(&mut swarm, addr)?;
+        swarm.dial_addr(addr)?;
         println!("Dialed {:?}", to_dial)
     }
 
     // Read full lines from stdin
     let mut stdin = io::BufReader::new(io::stdin()).lines();
 
     // Listen on all interfaces and whatever port the OS assigns
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     // Kick it off
     let mut listening = false;
     task::block_on(future::poll_fn(move |cx: &mut Context<'_>| {
         loop {
             if let Err(e) = match stdin.try_poll_next_unpin(cx)? {
                 Poll::Ready(Some(line)) => swarm
+                    .behaviour_mut()
                     .gossipsub
                     .publish(gossipsub_topic.clone(), line.as_bytes()),
                 Poll::Ready(None) => panic!("Stdin closed"),

examples/mdns-passive-discovery.rs

@@ -40,7 +40,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Note that the MDNS behaviour itself will not actually inititiate any connections,
     // as it only uses UDP.
     let mut swarm = Swarm::new(transport, behaviour, peer_id);
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     loop {
         match swarm.next().await {

examples/ping.rs

@@ -70,12 +70,12 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // command-line argument, if any.
     if let Some(addr) = std::env::args().nth(1) {
         let remote = addr.parse()?;
-        Swarm::dial_addr(&mut swarm, remote)?;
+        swarm.dial_addr(remote)?;
         println!("Dialed {}", addr)
     }
 
     // Tell the swarm to listen on all interfaces and a random, OS-assigned port.
-    Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 
     let mut listening = false;
     task::block_on(future::poll_fn(move |cx: &mut Context<'_>| {