feat(swarm): enforce creation of Swarm via SwarmBuilder

examples/chat-example/src/main.rs

@@ -48,7 +48,10 @@
 use async_std::io;
 use futures::{prelude::*, select};
 use libp2p::{
-    gossipsub, identity, mdns, swarm::NetworkBehaviour, swarm::SwarmEvent, PeerId, Swarm,
+    gossipsub, identity, mdns,
+    swarm::NetworkBehaviour,
+    swarm::{SwarmBuilder, SwarmEvent},
+    PeerId,
 };
 use std::collections::hash_map::DefaultHasher;
 use std::error::Error;
@@ -104,7 +107,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let mut swarm = {
         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)
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build()
     };
 
     // Read full lines from stdin

examples/distributed-key-value-store/src/main.rs

@@ -49,8 +49,8 @@ use libp2p::kad::{
 };
 use libp2p::{
     development_transport, identity, mdns,
-    swarm::{NetworkBehaviour, SwarmEvent},
-    PeerId, Swarm,
+    swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent},
+    PeerId,
 };
 use std::error::Error;
 
@@ -98,7 +98,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         let kademlia = Kademlia::new(local_peer_id, store);
         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)
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build()
     };
 
     // Read full lines from stdin

examples/file-sharing/src/network.rs

@@ -15,7 +15,7 @@ use libp2p::{
     },
     multiaddr::Protocol,
     request_response::{self, ProtocolSupport, RequestId, ResponseChannel},
-    swarm::{ConnectionHandlerUpgrErr, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{ConnectionHandlerUpgrErr, NetworkBehaviour, Swarm, SwarmBuilder, SwarmEvent},
     PeerId,
 };
 
@@ -47,7 +47,7 @@ pub async fn new(
 
     // Build the Swarm, connecting the lower layer transport logic with the
     // higher layer network behaviour logic.
-    let swarm = Swarm::with_threadpool_executor(
+    let swarm = SwarmBuilder::with_async_std_executor(
         libp2p::development_transport(id_keys).await?,
         ComposedBehaviour {
             kademlia: Kademlia::new(peer_id, MemoryStore::new(peer_id)),
@@ -58,7 +58,8 @@ pub async fn new(
             ),
         },
         peer_id,
-    );
+    )
+    .build();
 
     let (command_sender, command_receiver) = mpsc::channel(0);
     let (event_sender, event_receiver) = mpsc::channel(0);

examples/identify/src/main.rs

@@ -40,7 +40,7 @@ use futures::prelude::*;
 use libp2p::{
     core::{multiaddr::Multiaddr, upgrade::Version},
     identify, identity, noise,
-    swarm::{Swarm, SwarmEvent},
+    swarm::{SwarmBuilder, SwarmEvent},
     tcp, yamux, PeerId, Transport,
 };
 use std::error::Error;
@@ -63,7 +63,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
         local_key.public(),
     ));
 
-    let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+    let mut swarm =
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
 
     // Tell the swarm to listen on all interfaces and a random, OS-assigned
     // port.

examples/ipfs-kad/src/main.rs

@@ -28,7 +28,7 @@ use libp2p::kad::record::store::MemoryStore;
 use libp2p::kad::{GetClosestPeersError, Kademlia, KademliaConfig, KademliaEvent, QueryResult};
 use libp2p::{
     development_transport, identity,
-    swarm::{Swarm, SwarmEvent},
+    swarm::{SwarmBuilder, SwarmEvent},
     PeerId,
 };
 use std::{env, error::Error, time::Duration};
@@ -66,7 +66,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
             behaviour.add_address(&peer.parse()?, "/dnsaddr/bootstrap.libp2p.io".parse()?);
         }
 
-        Swarm::with_async_std_executor(transport, behaviour, local_peer_id)
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build()
     };
 
     // Order Kademlia to search for a peer.

examples/ipfs-private/src/main.rs

@@ -40,10 +40,10 @@ use libp2p::{
     multiaddr::Protocol,
     noise, ping,
     pnet::{PnetConfig, PreSharedKey},
-    swarm::{NetworkBehaviour, SwarmEvent},
+    swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp,
     yamux::YamuxConfig,
-    Multiaddr, PeerId, Swarm, Transport,
+    Multiaddr, PeerId, Transport,
 };
 use std::{env, error::Error, fs, path::Path, str::FromStr, time::Duration};
 
@@ -199,7 +199,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
         println!("Subscribing to {gossipsub_topic:?}");
         behaviour.gossipsub.subscribe(&gossipsub_topic).unwrap();
-        Swarm::with_async_std_executor(transport, behaviour, local_peer_id)
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build()
     };
 
     // Reach out to other nodes if specified

examples/ping-example/src/main.rs

@@ -43,7 +43,7 @@
 use futures::prelude::*;
 use libp2p::{
     identity, ping,
-    swarm::{keep_alive, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     Multiaddr, PeerId,
 };
 use std::error::Error;
@@ -56,7 +56,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let transport = libp2p::development_transport(local_key).await?;
 
-    let mut swarm = Swarm::with_async_std_executor(transport, Behaviour::default(), local_peer_id);
+    let mut swarm =
+        SwarmBuilder::with_async_std_executor(transport, Behaviour::default(), local_peer_id)
+            .build();
 
     // Tell the swarm to listen on all interfaces and a random, OS-assigned
     // port.

examples/rendezvous/src/bin/rzv-discover.rs

@@ -24,7 +24,7 @@ use libp2p::{
     identity,
     multiaddr::Protocol,
     noise, ping, rendezvous,
-    swarm::{keep_alive, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp, yamux, Multiaddr, PeerId, Transport,
 };
 use std::time::Duration;
@@ -41,7 +41,7 @@ async fn main() {
         .parse()
         .unwrap();
 
-    let mut swarm = Swarm::with_tokio_executor(
+    let mut swarm = SwarmBuilder::with_tokio_executor(
         tcp::tokio::Transport::default()
             .upgrade(Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&key_pair).unwrap())
@@ -53,7 +53,8 @@ async fn main() {
             keep_alive: keep_alive::Behaviour,
         },
         PeerId::from(key_pair.public()),
-    );
+    )
+    .build();
 
     log::info!("Local peer id: {}", swarm.local_peer_id());
 

examples/rendezvous/src/bin/rzv-identify.rs

@@ -22,7 +22,7 @@ use futures::StreamExt;
 use libp2p::{
     core::transport::upgrade::Version,
     identify, identity, noise, ping, rendezvous,
-    swarm::{keep_alive, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp, yamux, Multiaddr, PeerId, Transport,
 };
 use std::time::Duration;
@@ -37,7 +37,7 @@ async fn main() {
         .parse()
         .unwrap();
 
-    let mut swarm = Swarm::with_tokio_executor(
+    let mut swarm = SwarmBuilder::with_tokio_executor(
         tcp::tokio::Transport::default()
             .upgrade(Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&key_pair).unwrap())
@@ -53,7 +53,8 @@ async fn main() {
             keep_alive: keep_alive::Behaviour,
         },
         PeerId::from(key_pair.public()),
-    );
+    )
+    .build();
 
     log::info!("Local peer id: {}", swarm.local_peer_id());
 

examples/rendezvous/src/bin/rzv-register.rs

@@ -22,7 +22,7 @@ use futures::StreamExt;
 use libp2p::{
     core::transport::upgrade::Version,
     identity, noise, ping, rendezvous,
-    swarm::{keep_alive, AddressScore, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{keep_alive, AddressScore, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp, yamux, Multiaddr, PeerId, Transport,
 };
 use std::time::Duration;
@@ -37,7 +37,7 @@ async fn main() {
         .parse()
         .unwrap();
 
-    let mut swarm = Swarm::with_tokio_executor(
+    let mut swarm = SwarmBuilder::with_tokio_executor(
         tcp::tokio::Transport::default()
             .upgrade(Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&key_pair).unwrap())
@@ -49,7 +49,8 @@ async fn main() {
             keep_alive: keep_alive::Behaviour,
         },
         PeerId::from(key_pair.public()),
-    );
+    )
+    .build();
 
     // In production the external address should be the publicly facing IP address of the rendezvous point.
     // This address is recorded in the registration entry by the rendezvous point.

examples/rendezvous/src/main.rs

@@ -40,7 +40,7 @@ use futures::StreamExt;
 use libp2p::{
     core::transport::upgrade::Version,
     identify, identity, noise, ping, rendezvous,
-    swarm::{keep_alive, NetworkBehaviour, Swarm, SwarmEvent},
+    swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp, yamux, PeerId, Transport,
 };
 use std::time::Duration;
@@ -51,7 +51,7 @@ async fn main() {
 
     let key_pair = identity::Keypair::generate_ed25519();
 
-    let mut swarm = Swarm::with_tokio_executor(
+    let mut swarm = SwarmBuilder::with_tokio_executor(
         tcp::tokio::Transport::default()
             .upgrade(Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&key_pair).unwrap())
@@ -67,7 +67,8 @@ async fn main() {
             keep_alive: keep_alive::Behaviour,
         },
         PeerId::from(key_pair.public()),
-    );
+    )
+    .build();
 
     log::info!("Local peer id: {}", swarm.local_peer_id());
 

interop-tests/src/bin/ping.rs

@@ -13,8 +13,8 @@ use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmEvent};
 use libp2p::tls::TlsStream;
 use libp2p::websocket::WsConfig;
 use libp2p::{
-    identity, mplex, noise, ping, quic, tcp, tls, webrtc, yamux, InboundUpgradeExt, Multiaddr,
-    OutboundUpgradeExt, PeerId, Swarm, Transport as _,
+    identity, mplex, noise, ping, quic, swarm::SwarmBuilder, tcp, tls, webrtc, yamux,
+    InboundUpgradeExt, Multiaddr, OutboundUpgradeExt, PeerId, Transport as _,
 };
 use redis::AsyncCommands;
 
@@ -78,14 +78,15 @@ async fn main() -> Result<()> {
         ),
     };
 
-    let mut swarm = Swarm::with_tokio_executor(
+    let mut swarm = SwarmBuilder::with_tokio_executor(
         boxed_transport,
         Behaviour {
             ping: ping::Behaviour::new(ping::Config::new().with_interval(Duration::from_secs(1))),
             keep_alive: keep_alive::Behaviour,
         },
         local_peer_id,
-    );
+    )
+    .build();
 
     let mut conn = client.get_async_connection().await?;
 

misc/metrics/examples/metrics/main.rs

@@ -58,10 +58,7 @@ use libp2p_identity::PeerId;
 use libp2p_metrics::{Metrics, Recorder};
 use libp2p_noise as noise;
 use libp2p_ping as ping;
-use libp2p_swarm::keep_alive;
-use libp2p_swarm::NetworkBehaviour;
-use libp2p_swarm::Swarm;
-use libp2p_swarm::SwarmEvent;
+use libp2p_swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent};
 use libp2p_tcp as tcp;
 use libp2p_yamux as yamux;
 use log::info;
@@ -79,15 +76,16 @@ fn main() -> Result<(), Box<dyn Error>> {
     let local_pub_key = local_key.public();
     info!("Local peer id: {local_peer_id:?}");
 
-    let mut swarm = Swarm::without_executor(
+    let mut swarm = SwarmBuilder::without_executor(
         tcp::async_io::Transport::default()
             .upgrade(Version::V1)
             .authenticate(noise::NoiseAuthenticated::xx(&local_key)?)
             .multiplex(yamux::YamuxConfig::default())
             .boxed(),
         Behaviour::new(local_pub_key),
         local_peer_id,
-    );
+    )
+    .build();
 
     swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
 

misc/multistream-select/tests/transport.rs

@@ -29,7 +29,7 @@ use libp2p_identity as identity;
 use libp2p_identity::PeerId;
 use libp2p_mplex::MplexConfig;
 use libp2p_plaintext::PlainText2Config;
-use libp2p_swarm::{dummy, Swarm, SwarmEvent};
+use libp2p_swarm::{dummy, SwarmBuilder, SwarmEvent};
 use rand::random;
 use std::task::Poll;
 
@@ -63,9 +63,14 @@ fn transport_upgrade() {
         let listen_addr = Multiaddr::from(Protocol::Memory(random::<u64>()));
 
         let mut dialer =
-            Swarm::with_async_std_executor(dialer_transport, dummy::Behaviour, dialer_id);
-        let mut listener =
-            Swarm::with_async_std_executor(listener_transport, dummy::Behaviour, listener_id);
+            SwarmBuilder::with_async_std_executor(dialer_transport, dummy::Behaviour, dialer_id)
+                .build();
+        let mut listener = SwarmBuilder::with_async_std_executor(
+            listener_transport,
+            dummy::Behaviour,
+            listener_id,
+        )
+        .build();
 
         listener.listen_on(listen_addr).unwrap();
         let (addr_sender, addr_receiver) = oneshot::channel();

protocols/autonat/examples/autonat_client.rs

@@ -38,7 +38,7 @@ use libp2p_identify as identify;
 use libp2p_identity as identity;
 use libp2p_identity::PeerId;
 use libp2p_noise as noise;
-use libp2p_swarm::{NetworkBehaviour, Swarm, SwarmEvent};
+use libp2p_swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
 use libp2p_tcp as tcp;
 use libp2p_yamux as yamux;
 use std::error::Error;
@@ -76,7 +76,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let behaviour = Behaviour::new(local_key.public());
 
-    let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+    let mut swarm =
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
     swarm.listen_on(
         Multiaddr::empty()
             .with(Protocol::Ip4(Ipv4Addr::UNSPECIFIED))

protocols/autonat/examples/autonat_server.rs

@@ -34,7 +34,7 @@ use libp2p_identify as identify;
 use libp2p_identity as identity;
 use libp2p_identity::PeerId;
 use libp2p_noise as noise;
-use libp2p_swarm::{NetworkBehaviour, Swarm, SwarmEvent};
+use libp2p_swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
 use libp2p_tcp as tcp;
 use libp2p_yamux as yamux;
 use std::error::Error;
@@ -65,7 +65,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let behaviour = Behaviour::new(local_key.public());
 
-    let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+    let mut swarm =
+        SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
     swarm.listen_on(
         Multiaddr::empty()
             .with(Protocol::Ip4(Ipv4Addr::UNSPECIFIED))