misc/mdns: Make MdnsService::new sync by using std::net::UdpSocket::bind (#1382)

* misc/mdns: Make MdnsService::new sync by using std::net::UdpSocket::bind

MdnsService uses an IP address to create a UDP socket. The address does
not need to be resolved. Therefore one can use std's UdpSocket::bind
instead of the async counterpart from async-std. As a result
MdnsService::new and MdnsService::silent don't need to be async.

* examples/mdns-passive-discovery: Don't await sync MdnsService::new

* misc/mdns/src/behaviour: Make Mdns::new sync

Co-authored-by: Pierre Krieger <pierre.krieger1708@gmail.com>

examples/chat.rs

@@ -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 = Mdns::new()?;
         let mut behaviour = MyBehaviour {
             floodsub: Floodsub::new(local_peer_id.clone()),
             mdns,

examples/distributed-key-value-store.rs

@@ -113,7 +113,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 = Mdns::new()?;
         let behaviour = MyBehaviour { kademlia, mdns };
         Swarm::new(transport, behaviour, local_peer_id)
     };

examples/mdns-passive-discovery.rs

@@ -26,7 +26,7 @@ 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?;
+        let mut service = MdnsService::new()?;
         loop {
             let (srv, packet) = service.next().await;
             match packet {

misc/mdns/src/behaviour.rs

@@ -88,9 +88,9 @@ impl fmt::Debug for MaybeBusyMdnsService {
 
 impl<TSubstream> Mdns<TSubstream> {
     /// Builds a new `Mdns` behaviour.
-    pub async fn new() -> io::Result<Mdns<TSubstream>> {
+    pub fn new() -> io::Result<Mdns<TSubstream>> {
         Ok(Mdns {
-            service: MaybeBusyMdnsService::Free(MdnsService::new().await?),
+            service: MaybeBusyMdnsService::Free(MdnsService::new()?),
             discovered_nodes: SmallVec::new(),
             closest_expiration: None,
             marker: PhantomData,

misc/mdns/src/service.rs

@@ -68,7 +68,7 @@ lazy_static! {
 /// # let my_peer_id = PeerId::from(identity::Keypair::generate_ed25519().public());
 /// # let my_listened_addrs: Vec<Multiaddr> = vec![];
 /// # block_on(async {
-/// let mut service = MdnsService::new().await.expect("Error while creating mDNS service");
+/// let mut service = MdnsService::new().expect("Error while creating mDNS service");
 /// let _future_to_poll = async {
 ///     let (mut service, packet) = service.next().await;
 ///
@@ -123,19 +123,17 @@ pub struct MdnsService {
 
 impl MdnsService {
     /// Starts a new mDNS service.
-    #[inline]
-    pub async fn new() -> io::Result<MdnsService> {
-        Self::new_inner(false).await
+    pub fn new() -> io::Result<MdnsService> {
+        Self::new_inner(false)
     }
 
     /// Same as `new`, but we don't send automatically send queries on the network.
-    #[inline]
-    pub async fn silent() -> io::Result<MdnsService> {
-        Self::new_inner(true).await
+    pub fn silent() -> io::Result<MdnsService> {
+        Self::new_inner(true)
     }
 
     /// Starts a new mDNS service.
-    async fn new_inner(silent: bool) -> io::Result<MdnsService> {
+    fn new_inner(silent: bool) -> io::Result<MdnsService> {
         let socket = {
             #[cfg(unix)]
             fn platform_specific(s: &net2::UdpBuilder) -> io::Result<()> {
@@ -158,7 +156,9 @@ impl MdnsService {
 
         Ok(MdnsService {
             socket,
-            query_socket: UdpSocket::bind((Ipv4Addr::from([0u8, 0, 0, 0]), 0u16)).await?,
+            // Given that we pass an IP address to bind, which does not need to be resolved, we can
+            // use std::net::UdpSocket::bind, instead of its async counterpart from async-std.
+            query_socket: std::net::UdpSocket::bind((Ipv4Addr::from([0u8, 0, 0, 0]), 0u16))?.into(),
             query_interval: Interval::new_at(Instant::now(), Duration::from_secs(20)),
             silent,
             recv_buffer: [0; 2048],
@@ -556,7 +556,7 @@ mod tests {
 
     fn discover(peer_id: PeerId) {
         block_on(async {
-            let mut service = MdnsService::new().await.unwrap();
+            let mut service = MdnsService::new().unwrap();
             loop {
                 let next = service.next().await;
                 service = next.0;
@@ -594,7 +594,7 @@ mod tests {
             .collect();
 
         let fut = async {
-            let mut service = MdnsService::new().await.unwrap();
+            let mut service = MdnsService::new().unwrap();
             let mut sent_queries = vec![];
 
             loop {