feat(libp2p): add SwarmBuilder

Cargo.toml

@@ -71,7 +71,7 @@ rust-version = "1.65.0"
 
 [workspace.dependencies]
 futures-bounded = { version = "0.1.0", path = "misc/futures-bounded" }
-libp2p = { version = "0.52.3", path = "libp2p" }
+libp2p = { version = "0.52.4", path = "libp2p" }
 libp2p-allow-block-list = { version = "0.2.0", path = "misc/allow-block-list" }
 libp2p-autonat = { version = "0.11.0", path = "protocols/autonat" }
 libp2p-connection-limits = { version = "0.2.1", path = "misc/connection-limits" }
@@ -100,7 +100,7 @@ libp2p-rendezvous = { version = "0.13.0", path = "protocols/rendezvous" }
 libp2p-upnp = { version = "0.1.1", path = "protocols/upnp" }
 libp2p-request-response = { version = "0.25.1", path = "protocols/request-response" }
 libp2p-server = { version = "0.12.3", path = "misc/server" }
-libp2p-swarm = { version = "0.43.5", path = "swarm" }
+libp2p-swarm = { version = "0.43.6", path = "swarm" }
 libp2p-swarm-derive = { version = "0.33.0", path = "swarm-derive" }
 libp2p-swarm-test = { version = "0.2.0", path = "swarm-test" }
 libp2p-tcp = { version = "0.40.0", path = "transports/tcp" }

examples/autonat/src/bin/autonat_client.rs

@@ -21,10 +21,10 @@
 #![doc = include_str!("../../README.md")]
 
 use clap::Parser;
-use futures::prelude::*;
+use futures::StreamExt;
 use libp2p::core::multiaddr::Protocol;
-use libp2p::core::{upgrade::Version, Multiaddr, Transport};
-use libp2p::swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
+use libp2p::core::Multiaddr;
+use libp2p::swarm::{NetworkBehaviour, SwarmEvent};
 use libp2p::{autonat, identify, identity, noise, tcp, yamux, PeerId};
 use std::error::Error;
 use std::net::Ipv4Addr;
@@ -49,18 +49,16 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let opt = Opt::parse();
 
-    let local_key = identity::Keypair::generate_ed25519();
-    let local_peer_id = PeerId::from(local_key.public());
+    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
+        .with_tokio()
+        .with_tcp(
+            tcp::Config::default(),
+            noise::Config::new,
+            yamux::Config::default,
+        )?
+        .with_behaviour(|key| Behaviour::new(key.public()))?
+        .build();
 
-    let transport = tcp::tokio::Transport::default()
-        .upgrade(Version::V1Lazy)
-        .authenticate(noise::Config::new(&local_key)?)
-        .multiplex(yamux::Config::default())
-        .boxed();
-
-    let behaviour = Behaviour::new(local_key.public());
-
-    let mut swarm = SwarmBuilder::with_tokio_executor(transport, behaviour, local_peer_id).build();
     swarm.listen_on(
         Multiaddr::empty()
             .with(Protocol::Ip4(Ipv4Addr::UNSPECIFIED))

examples/autonat/src/bin/autonat_server.rs

@@ -21,10 +21,10 @@
 #![doc = include_str!("../../README.md")]
 
 use clap::Parser;
-use futures::prelude::*;
-use libp2p::core::{multiaddr::Protocol, upgrade::Version, Multiaddr, Transport};
-use libp2p::swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
-use libp2p::{autonat, identify, identity, noise, tcp, yamux, PeerId};
+use futures::StreamExt;
+use libp2p::core::{multiaddr::Protocol, Multiaddr};
+use libp2p::swarm::{NetworkBehaviour, SwarmEvent};
+use libp2p::{autonat, identify, identity, noise, tcp, yamux};
 use std::error::Error;
 use std::net::Ipv4Addr;
 
@@ -41,18 +41,16 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let opt = Opt::parse();
 
-    let local_key = identity::Keypair::generate_ed25519();
-    let local_peer_id = PeerId::from(local_key.public());
+    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
+        .with_tokio()
+        .with_tcp(
+            tcp::Config::default(),
+            noise::Config::new,
+            yamux::Config::default,
+        )?
+        .with_behaviour(|key| Behaviour::new(key.public()))?
+        .build();
 
-    let transport = tcp::tokio::Transport::default()
-        .upgrade(Version::V1Lazy)
-        .authenticate(noise::Config::new(&local_key)?)
-        .multiplex(yamux::Config::default())
-        .boxed();
-
-    let behaviour = Behaviour::new(local_key.public());
-
-    let mut swarm = SwarmBuilder::with_tokio_executor(transport, behaviour, local_peer_id).build();
     swarm.listen_on(
         Multiaddr::empty()
             .with(Protocol::Ip4(Ipv4Addr::UNSPECIFIED))

examples/browser-webrtc/src/lib.rs

@@ -6,6 +6,7 @@ use libp2p::core::Multiaddr;
 use libp2p::identity::{Keypair, PeerId};
 use libp2p::ping;
 use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent};
+use libp2p::webrtc_websys;
 use std::convert::From;
 use std::io;
 use wasm_bindgen::prelude::*;
@@ -18,19 +19,16 @@ pub async fn run(libp2p_endpoint: String) -> Result<(), JsError> {
     let body = Body::from_current_window()?;
     body.append_p("Let's ping the WebRTC Server!")?;
 
-    let local_key = Keypair::generate_ed25519();
-    let local_peer_id = PeerId::from(local_key.public());
-    let mut swarm = SwarmBuilder::with_wasm_executor(
-        libp2p_webrtc_websys::Transport::new(libp2p_webrtc_websys::Config::new(&local_key)).boxed(),
-        Behaviour {
+    let swarm = libp2p::SwarmBuilder::with_new_identity()
+        .with_wasm_bindgen()
+        .with_other_transport(|key| {
+            webrtc_websys::Transport::new(webrtc_websys::Config::new(&key))
+        })?
+        .with_behaviour(|_| Behaviour {
             ping: ping::Behaviour::new(ping::Config::new()),
             keep_alive: keep_alive::Behaviour,
-        },
-        local_peer_id,
-    )
-    .build();
-
-    log::info!("Initialize swarm with identity: {local_peer_id}");
+        })?
+        .build();
 
     let addr = libp2p_endpoint.parse::<Multiaddr>()?;
     log::info!("Dialing {addr}");

examples/browser-webrtc/src/main.rs

@@ -10,10 +10,9 @@ use futures::StreamExt;
 use libp2p::{
     core::muxing::StreamMuxerBox,
     core::Transport,
-    identity,
     multiaddr::{Multiaddr, Protocol},
     ping,
-    swarm::{SwarmBuilder, SwarmEvent},
+    swarm::SwarmEvent,
 };
 use libp2p_webrtc as webrtc;
 use rand::thread_rng;
@@ -28,19 +27,22 @@ async fn main() -> anyhow::Result<()> {
         .parse_default_env()
         .init();
 
-    let id_keys = identity::Keypair::generate_ed25519();
-    let local_peer_id = id_keys.public().to_peer_id();
-    let transport = webrtc::tokio::Transport::new(
-        id_keys,
-        webrtc::tokio::Certificate::generate(&mut thread_rng())?,
-    )
-    .map(|(peer_id, conn), _| (peer_id, StreamMuxerBox::new(conn)))
-    .boxed();
-
-    let mut swarm =
-        SwarmBuilder::with_tokio_executor(transport, ping::Behaviour::default(), local_peer_id)
-            .idle_connection_timeout(Duration::from_secs(30)) // Allows us to observe the pings.
-            .build();
+    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
+        .with_tokio()
+        .with_other_transport(|id_keys| {
+            Ok(webrtc::tokio::Transport::new(
+                id_keys.clone(),
+                webrtc::tokio::Certificate::generate(&mut thread_rng())?,
+            )
+            .map(|(peer_id, conn), _| (peer_id, StreamMuxerBox::new(conn))))
+        })?
+        .with_behaviour(|_| ping::Behaviour::default())?
+        .with_swarm_config(|cfg| {
+            cfg.with_idle_connection_timeout(
+                Duration::from_secs(30), // Allows us to observe the pings.
+            )
+        })
+        .build();
 
     let address_webrtc = Multiaddr::from(Ipv4Addr::UNSPECIFIED)
         .with(Protocol::Udp(0))

examples/chat/src/main.rs

@@ -20,14 +20,8 @@
 
 #![doc = include_str!("../README.md")]
 
-use futures::{future::Either, stream::StreamExt};
-use libp2p::{
-    core::{muxing::StreamMuxerBox, transport::OrTransport, upgrade},
-    gossipsub, identity, mdns, noise, quic,
-    swarm::NetworkBehaviour,
-    swarm::{SwarmBuilder, SwarmEvent},
-    tcp, yamux, PeerId, Transport,
-};
+use futures::stream::StreamExt;
+use libp2p::{gossipsub, mdns, noise, swarm::NetworkBehaviour, swarm::SwarmEvent, tcp, yamux};
 use std::collections::hash_map::DefaultHasher;
 use std::error::Error;
 use std::hash::{Hash, Hasher};
@@ -43,58 +37,46 @@ struct MyBehaviour {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-    // Create a random PeerId
-    env_logger::init();
-    let id_keys = identity::Keypair::generate_ed25519();
-    let local_peer_id = PeerId::from(id_keys.public());
+    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
+        .with_tokio()
+        .with_tcp(
+            tcp::Config::default(),
+            noise::Config::new,
+            yamux::Config::default,
+        )?
+        .with_quic()
+        .with_behaviour(|key| {
+            // To content-address message, we can take the hash of message and use it as an ID.
+            let message_id_fn = |message: &gossipsub::Message| {
+                let mut s = DefaultHasher::new();
+                message.data.hash(&mut s);
+                gossipsub::MessageId::from(s.finish().to_string())
+            };
 
-    // Set up an encrypted DNS-enabled TCP Transport over the yamux protocol.
-    let tcp_transport = tcp::tokio::Transport::new(tcp::Config::default().nodelay(true))
-        .upgrade(upgrade::Version::V1Lazy)
-        .authenticate(noise::Config::new(&id_keys).expect("signing libp2p-noise static keypair"))
-        .multiplex(yamux::Config::default())
-        .timeout(std::time::Duration::from_secs(20))
-        .boxed();
-    let quic_transport = quic::tokio::Transport::new(quic::Config::new(&id_keys));
-    let transport = OrTransport::new(quic_transport, tcp_transport)
-        .map(|either_output, _| match either_output {
-            Either::Left((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
-            Either::Right((peer_id, muxer)) => (peer_id, StreamMuxerBox::new(muxer)),
-        })
-        .boxed();
+            // Set a custom gossipsub configuration
+            let gossipsub_config = gossipsub::ConfigBuilder::default()
+                .heartbeat_interval(Duration::from_secs(10)) // This is set to aid debugging by not cluttering the log space
+                .validation_mode(gossipsub::ValidationMode::Strict) // This sets the kind of message validation. The default is Strict (enforce message signing)
+                .message_id_fn(message_id_fn) // content-address messages. No two messages of the same content will be propagated.
+                .build()
+                .map_err(|msg| io::Error::new(io::ErrorKind::Other, msg))?; // Temporary hack because `build` does not return a proper `std::error::Error`.
 
-    // To content-address message, we can take the hash of message and use it as an ID.
-    let message_id_fn = |message: &gossipsub::Message| {
-        let mut s = DefaultHasher::new();
-        message.data.hash(&mut s);
-        gossipsub::MessageId::from(s.finish().to_string())
-    };
+            // build a gossipsub network behaviour
+            let gossipsub = gossipsub::Behaviour::new(
+                gossipsub::MessageAuthenticity::Signed(key.clone()),
+                gossipsub_config,
+            )?;
 
-    // Set a custom gossipsub configuration
-    let gossipsub_config = gossipsub::ConfigBuilder::default()
-        .heartbeat_interval(Duration::from_secs(10)) // This is set to aid debugging by not cluttering the log space
-        .validation_mode(gossipsub::ValidationMode::Strict) // This sets the kind of message validation. The default is Strict (enforce message signing)
-        .message_id_fn(message_id_fn) // content-address messages. No two messages of the same content will be propagated.
-        .build()
-        .expect("Valid config");
+            let mdns =
+                mdns::tokio::Behaviour::new(mdns::Config::default(), key.public().to_peer_id())?;
+            Ok(MyBehaviour { gossipsub, mdns })
+        })?
+        .build();
 
-    // build a gossipsub network behaviour
-    let mut gossipsub = gossipsub::Behaviour::new(
-        gossipsub::MessageAuthenticity::Signed(id_keys),
-        gossipsub_config,
-    )
-    .expect("Correct configuration");
     // Create a Gossipsub topic
     let topic = gossipsub::IdentTopic::new("test-net");
     // subscribes to our topic
-    gossipsub.subscribe(&topic)?;
-
-    // Create a Swarm to manage peers and events
-    let mut swarm = {
-        let mdns = mdns::tokio::Behaviour::new(mdns::Config::default(), local_peer_id)?;
-        let behaviour = MyBehaviour { gossipsub, mdns };
-        SwarmBuilder::with_tokio_executor(transport, behaviour, local_peer_id).build()
-    };
+    swarm.behaviour_mut().gossipsub.subscribe(&topic)?;
 
     // Read full lines from stdin
     let mut stdin = io::BufReader::new(io::stdin()).lines();

examples/dcutr/Cargo.toml

@@ -10,5 +10,6 @@ clap = { version = "4.3.23", features = ["derive"] }
 env_logger = "0.10.0"
 futures = "0.3.28"
 futures-timer = "3.0"
-libp2p = { path = "../../libp2p", features = ["async-std", "dns", "dcutr", "identify", "macros", "noise", "ping", "quic", "relay", "rendezvous", "tcp", "tokio", "yamux"] }
+libp2p = { path = "../../libp2p", features = ["dns", "dcutr", "identify", "macros", "noise", "ping", "quic", "relay", "rendezvous", "tcp", "tokio", "yamux"] }
 log = "0.4"
+tokio = { version = "1.29", features = ["macros", "net", "rt", "signal"] }