Don't poll network unnecessarily.

examples/chat-tokio.rs

@@ -120,7 +120,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     // Create a Swarm to manage peers and events.
     let mut swarm = {
-        let mdns = Mdns::new().await?;
+        let mdns = Mdns::new(Default::default()).await?;
         let mut behaviour = MyBehaviour {
             floodsub: Floodsub::new(peer_id.clone()),
             mdns,
@@ -175,4 +175,4 @@ async fn main() -> Result<(), Box<dyn Error>> {
             }
         }
     }
-}
+}

examples/chat.rs

@@ -58,7 +58,7 @@ use libp2p::{
     NetworkBehaviour,
     identity,
     floodsub::{self, Floodsub, FloodsubEvent},
-    mdns::{Mdns, MdnsEvent},
+    mdns::{Mdns, MdnsConfig, MdnsEvent},
     swarm::NetworkBehaviourEventProcess
 };
 use std::{error::Error, task::{Context, Poll}};
@@ -121,7 +121,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     // Create a Swarm to manage peers and events
     let mut swarm = {
-        let mdns = task::block_on(Mdns::new())?;
+        let mdns = task::block_on(Mdns::new(MdnsConfig::default()))?;
         let mut behaviour = MyBehaviour {
             floodsub: Floodsub::new(local_peer_id.clone()),
             mdns,

examples/distributed-key-value-store.rs

@@ -60,7 +60,7 @@ use libp2p::{
     Swarm,
     build_development_transport,
     identity,
-    mdns::{Mdns, MdnsEvent},
+    mdns::{Mdns, MdnsConfig, MdnsEvent},
     swarm::NetworkBehaviourEventProcess
 };
 use std::{error::Error, task::{Context, Poll}};
@@ -151,7 +151,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         // Create a Kademlia behaviour.
         let store = MemoryStore::new(local_peer_id.clone());
         let kademlia = Kademlia::new(local_peer_id.clone(), store);
-        let mdns = task::block_on(Mdns::new())?;
+        let mdns = task::block_on(Mdns::new(MdnsConfig::default()))?;
         let behaviour = MyBehaviour { kademlia, mdns };
         Swarm::new(transport, behaviour, local_peer_id)
     };

examples/mdns-passive-discovery.rs

@@ -18,43 +18,42 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use async_std::task;
-use libp2p::mdns::service::{MdnsPacket, MdnsService};
+use libp2p::{identity, mdns::{Mdns, MdnsConfig, MdnsEvent}, PeerId, Swarm};
 use std::error::Error;
 
-fn main() -> Result<(), Box<dyn Error>> {
-    // This example provides passive discovery of the libp2p nodes on the
-    // network that send mDNS queries and answers.
-    task::block_on(async move {
-        let mut service = MdnsService::new().await?;
-        loop {
-            let (srv, packet) = service.next().await;
-            match packet {
-                MdnsPacket::Query(query) => {
-                    // We detected a libp2p mDNS query on the network. In a real application, you
-                    // probably want to answer this query by doing `query.respond(...)`.
-                    println!("Detected query from {:?}", query.remote_addr());
-                }
-                MdnsPacket::Response(response) => {
-                    // We detected a libp2p mDNS response on the network. Responses are for
-                    // everyone and not just for the requester, which makes it possible to
-                    // passively listen.
-                    for peer in response.discovered_peers() {
-                        println!("Discovered peer {:?}", peer.id());
-                        // These are the self-reported addresses of the peer we just discovered.
-                        for addr in peer.addresses() {
-                            println!(" Address = {:?}", addr);
-                        }
-                    }
+#[async_std::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::init();
+
+    // Create a random PeerId.
+    let id_keys = identity::Keypair::generate_ed25519();
+    let peer_id = PeerId::from(id_keys.public());
+    println!("Local peer id: {:?}", peer_id);
+
+    // Create a transport.
+    let transport = libp2p::build_development_transport(id_keys)?;
+
+    // Create an MDNS network behaviour.
+    let behaviour = Mdns::new(MdnsConfig::default()).await?;
+
+    // Create a Swarm that establishes connections through the given transport.
+    // 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()?)?;
+
+    loop {
+        match swarm.next().await {
+            MdnsEvent::Discovered(peers) => {
+                for (peer, addr) in peers {
+                    println!("discovered {} {}", peer, addr);
                 }
-                MdnsPacket::ServiceDiscovery(query) => {
-                    // The last possibility is a service detection query from DNS-SD.
-                    // Just like `Query`, in a real application you probably want to call
-                    // `query.respond`.
-                    println!("Detected service query from {:?}", query.remote_addr());
+            }
+            MdnsEvent::Expired(expired) => {
+                for (peer, addr) in expired {
+                    println!("expired {} {}", peer, addr);
                 }
             }
-            service = srv
         }
-    })
+    }
 }

protocols/mdns/Cargo.toml

@@ -10,21 +10,21 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
 categories = ["network-programming", "asynchronous"]
 
 [dependencies]
-async-io = "1.3.0"
-data-encoding = "2.3.1"
+async-io = "1.3.1"
+data-encoding = "2.3.2"
 dns-parser = "0.8.0"
-futures = "0.3.8"
-if-watch = "0.1.8"
+futures = "0.3.13"
+if-watch = "0.2.0"
 lazy_static = "1.4.0"
 libp2p-core = { version = "0.27.0", path = "../../core" }
 libp2p-swarm = { version = "0.28.0", path = "../../swarm" }
-log = "0.4.11"
-rand = "0.7.3"
-smallvec = "1.5.0"
-socket2 = { version = "0.3.17", features = ["reuseport"] }
+log = "0.4.14"
+rand = "0.8.3"
+smallvec = "1.6.1"
+socket2 = { version = "0.3.19", features = ["reuseport"] }
 void = "1.0.2"
 
 [dev-dependencies]
-async-std = "1.7.0"
+async-std = "1.9.0"
 if-addrs = "0.6.5"
-tokio = { version = "1.0.1", default-features = false, features = ["rt", "rt-multi-thread"] }
+tokio = { version = "1.2.0", default-features = false, features = ["rt", "rt-multi-thread"] }