rename LocalSwarmDiscovery to MdnsDiscovery

Author: “ramfox”

iroh/examples/locally-discovered-nodes.rs

@@ -1,8 +1,8 @@
-//! A small example showing how to get a list of nodes that were discovered via [`iroh::discovery::LocalSwarmDiscovery`]. LocalSwarmDiscovery uses [`swarm-discovery`](https://crates.io/crates/swarm-discovery) to discover other nodes in the local network ala mDNS.
+//! A small example showing how to get a list of nodes that were discovered via [`iroh::discovery::MdnsDiscovery`]. MdnsDiscovery uses [`swarm-discovery`](https://crates.io/crates/swarm-discovery), an opinionated implementation of mDNS to discover other nodes in the local network.
 //!
 //! This example creates an iroh endpoint, a few additional iroh endpoints to discover, waits a few seconds, and reports all of the iroh NodeIds (also called `[iroh::key::PublicKey]`s) it has discovered.
 //!
-//! This is an async, non-determinate process, so the number of NodeIDs discovered each time may be different. If you have other iroh endpoints or iroh nodes with [`LocalSwarmDiscovery`] enabled, it may discover those nodes as well.
+//! This is an async, non-determinate process, so the number of NodeIDs discovered each time may be different. If you have other iroh endpoints or iroh nodes with [`MdnsDiscovery`] enabled, it may discover those nodes as well.
 use std::time::Duration;
 
 use anyhow::Result;

iroh/src/discovery.rs

@@ -34,8 +34,8 @@
 //! - The [`PkarrResolver`] which can perform lookups from designated [pkarr relay servers]
 //!   using HTTP.
 //!
-//! - [`LocalSwarmDiscovery`]: local_swarm_discovery::LocalSwarmDiscovery which is an mDNS
-//!   implementation.
+//! - [`MdnsDiscovery`]: mdns::MdnsDiscovery which uses the crate `swarm-discovery`, an
+//!   opinionated mDNS implementation, to discover nodes on the local network.
 //!
 //! - The [`DhtDiscovery`] also uses the [`pkarr`] system but can also publish and lookup
 //!   records to/from the Mainline DHT.
@@ -69,14 +69,14 @@
 //! # }
 //! ```
 //!
-//! To also enable [`LocalSwarmDiscovery`] it can be added as another service in the
+//! To also enable [`MdnsDiscovery`] it can be added as another service in the
 //! [`ConcurrentDiscovery`]:
 //!
 //! ```no_run
 //! # #[cfg(feature = "discovery-local-network")]
 //! # {
 //! # use iroh::discovery::dns::DnsDiscovery;
-//! # use iroh::discovery::local_swarm_discovery::LocalSwarmDiscovery;
+//! # use iroh::discovery::mdns::MdnsDiscovery;
 //! # use iroh::discovery::pkarr::PkarrPublisher;
 //! # use iroh::discovery::ConcurrentDiscovery;
 //! # use iroh::SecretKey;
@@ -86,7 +86,7 @@
 //! let discovery = ConcurrentDiscovery::from_services(vec![
 //!     Box::new(PkarrPublisher::n0_dns(secret_key.clone())),
 //!     Box::new(DnsDiscovery::n0_dns()),
-//!     Box::new(LocalSwarmDiscovery::new(secret_key.public())?),
+//!     Box::new(MdnsDiscovery::new(secret_key.public())?),
 //! ]);
 //! # Ok(())
 //! # }
@@ -102,7 +102,7 @@
 //! [`PkarrPublisher`]: pkarr::PkarrPublisher
 //! [`DhtDiscovery`]: pkarr::dht::DhtDiscovery
 //! [pkarr relay servers]: https://pkarr.org/#servers
-//! [`LocalSwarmDiscovery`]: local_swarm_discovery::LocalSwarmDiscovery
+//! [`MdnsDiscovery`]: mdns::MdnsDiscovery
 //! [`StaticProvider`]: static_provider::StaticProvider
 
 use std::sync::Arc;
@@ -126,7 +126,7 @@ use crate::Endpoint;
 pub mod dns;
 
 #[cfg(feature = "discovery-local-network")]
-pub mod local_swarm_discovery;
+pub mod mdns;
 pub mod pkarr;
 pub mod static_provider;
 

iroh/src/discovery/local_swarm_discovery.rs renamed to iroh/src/discovery/mdns.rs

@@ -3,7 +3,7 @@
 //! This allows you to use an mdns-like swarm discovery service to find address information about nodes that are on your local network, no relay or outside internet needed.
 //! See the [`swarm-discovery`](https://crates.io/crates/swarm-discovery) crate for more details.
 //!
-//! When [`LocalSwarmDiscovery`] is enabled, it's possible to get a list of the locally discovered nodes by filtering a list of `RemoteInfo`s.
+//! When [`MdnsDiscovery`] is enabled, it's possible to get a list of the locally discovered nodes by filtering a list of `RemoteInfo`s.
 //!
 //! ```
 //! use std::time::Duration;
@@ -20,7 +20,7 @@
 //!         .filter(|remote| {
 //!             remote.sources().iter().any(|(source, duration)| {
 //!                 if let Source::Discovery { name } = source {
-//!                     name == iroh::discovery::local_swarm_discovery::NAME && *duration <= recent
+//!                     name == iroh::discovery::mdns::NAME && *duration <= recent
 //!                 } else {
 //!                     false
 //!                 }
@@ -72,7 +72,7 @@ const DISCOVERY_DURATION: Duration = Duration::from_secs(10);
 
 /// Discovery using `swarm-discovery`, a variation on mdns
 #[derive(Debug)]
-pub struct LocalSwarmDiscovery {
+pub struct MdnsDiscovery {
     #[allow(dead_code)]
     handle: AbortOnDropHandle<()>,
     sender: mpsc::Sender<Message>,
@@ -128,8 +128,8 @@ impl Subscribers {
     }
 }
 
-impl LocalSwarmDiscovery {
-    /// Create a new [`LocalSwarmDiscovery`] Service.
+impl MdnsDiscovery {
+    /// Create a new [`MdnsDiscovery`] Service.
     ///
     /// This starts a [`Discoverer`] that broadcasts your addresses and receives addresses from other nodes in your local network.
     ///
@@ -139,16 +139,12 @@ impl LocalSwarmDiscovery {
     /// # Panics
     /// This relies on [`tokio::runtime::Handle::current`] and will panic if called outside of the context of a tokio runtime.
     pub fn new(node_id: NodeId) -> Result<Self> {
-        debug!("Creating new LocalSwarmDiscovery service");
+        debug!("Creating new MdnsDiscovery service");
         let (send, mut recv) = mpsc::channel(64);
         let task_sender = send.clone();
         let rt = tokio::runtime::Handle::current();
-        let discovery = LocalSwarmDiscovery::spawn_discoverer(
-            node_id,
-            task_sender.clone(),
-            BTreeSet::new(),
-            &rt,
-        )?;
+        let discovery =
+            MdnsDiscovery::spawn_discoverer(node_id, task_sender.clone(), BTreeSet::new(), &rt)?;
 
         let local_addrs: Watchable<Option<NodeData>> = Watchable::default();
         let mut addrs_change = local_addrs.watch();
@@ -162,16 +158,16 @@ impl LocalSwarmDiscovery {
             > = HashMap::default();
             let mut timeouts = JoinSet::new();
             loop {
-                trace!(?node_addrs, "LocalSwarmDiscovery Service loop tick");
+                trace!(?node_addrs, "MdnsDiscovery Service loop tick");
                 let msg = tokio::select! {
                     msg = recv.recv() => {
                         msg
                     }
                     Ok(Some(data)) = addrs_change.updated() => {
-                        tracing::trace!(?data, "LocalSwarmDiscovery address changed");
+                        tracing::trace!(?data, "MdnsDiscovery address changed");
                         discovery.remove_all();
                         let addrs =
-                            LocalSwarmDiscovery::socketaddrs_to_addrs(data.direct_addresses());
+                            MdnsDiscovery::socketaddrs_to_addrs(data.direct_addresses());
                         for addr in addrs {
                             discovery.add(addr.0, addr.1)
                         }
@@ -185,8 +181,8 @@ impl LocalSwarmDiscovery {
                 };
                 let msg = match msg {
                     None => {
-                        error!("LocalSwarmDiscovery channel closed");
-                        error!("closing LocalSwarmDiscovery");
+                        error!("MdnsDiscovery channel closed");
+                        error!("closing MdnsDiscovery");
                         timeouts.abort_all();
                         return;
                     }
@@ -197,7 +193,7 @@ impl LocalSwarmDiscovery {
                         trace!(
                             ?discovered_node_id,
                             ?peer_info,
-                            "LocalSwarmDiscovery Message::Discovery"
+                            "MdnsDiscovery Message::Discovery"
                         );
                         let discovered_node_id = match PublicKey::from_str(&discovered_node_id) {
                             Ok(node_id) => node_id,
@@ -217,7 +213,7 @@ impl LocalSwarmDiscovery {
                         if peer_info.is_expiry() {
                             trace!(
                                 ?discovered_node_id,
-                                "removing node from LocalSwarmDiscovery address book"
+                                "removing node from MdnsDiscovery address book"
                             );
                             node_addrs.remove(&discovered_node_id);
                             continue;
@@ -234,7 +230,7 @@ impl LocalSwarmDiscovery {
                         debug!(
                             ?discovered_node_id,
                             ?peer_info,
-                            "adding node to LocalSwarmDiscovery address book"
+                            "adding node to MdnsDiscovery address book"
                         );
 
                         let mut resolved = false;
@@ -258,7 +254,7 @@ impl LocalSwarmDiscovery {
                     Message::Resolve(node_id, sender) => {
                         let id = last_id + 1;
                         last_id = id;
-                        trace!(?node_id, "LocalSwarmDiscovery Message::SendAddrs");
+                        trace!(?node_id, "MdnsDiscovery Message::SendAddrs");
                         if let Some(peer_info) = node_addrs.get(&node_id) {
                             let item = peer_to_discovery_item(peer_info, &node_id);
                             debug!(?item, "sending DiscoveryItem");
@@ -282,7 +278,7 @@ impl LocalSwarmDiscovery {
                         });
                     }
                     Message::Timeout(node_id, id) => {
-                        trace!(?node_id, "LocalSwarmDiscovery Message::Timeout");
+                        trace!(?node_id, "MdnsDiscovery Message::Timeout");
                         if let Some(senders_for_node_id) = senders.get_mut(&node_id) {
                             senders_for_node_id.remove(&id);
                             if senders_for_node_id.is_empty() {
@@ -291,7 +287,7 @@ impl LocalSwarmDiscovery {
                         }
                     }
                     Message::Subscribe(subscriber) => {
-                        trace!("LocalSwarmDiscovery Message::Subscribe");
+                        trace!("MdnsDiscovery Message::Subscribe");
                         subscribers.push(subscriber);
                     }
                 }
@@ -316,7 +312,7 @@ impl LocalSwarmDiscovery {
             trace!(
                 node_id,
                 ?peer,
-                "Received peer information from LocalSwarmDiscovery"
+                "Received peer information from MdnsDiscovery"
             );
 
             let sender = sender.clone();
@@ -326,7 +322,7 @@ impl LocalSwarmDiscovery {
                 sender.send(Message::Discovery(node_id, peer)).await.ok();
             });
         };
-        let addrs = LocalSwarmDiscovery::socketaddrs_to_addrs(&socketaddrs);
+        let addrs = MdnsDiscovery::socketaddrs_to_addrs(&socketaddrs);
         let node_id_str = data_encoding::BASE32_NOPAD
             .encode(node_id.as_bytes())
             .to_ascii_lowercase();
@@ -376,7 +372,7 @@ fn peer_to_discovery_item(peer: &Peer, node_id: &NodeId) -> DiscoveryItem {
     DiscoveryItem::new(node_info, NAME, None)
 }
 
-impl Discovery for LocalSwarmDiscovery {
+impl Discovery for MdnsDiscovery {
     fn resolve(&self, _ep: Endpoint, node_id: NodeId) -> Option<BoxStream<Result<DiscoveryItem>>> {
         use futures_util::FutureExt;
 
@@ -425,7 +421,7 @@ mod tests {
 
         #[tokio::test]
         #[traced_test]
-        async fn local_swarm_discovery_publish_resolve() -> TestResult {
+        async fn mdns_publish_resolve() -> TestResult {
             let (_, discovery_a) = make_discoverer()?;
             let (node_id_b, discovery_b) = make_discoverer()?;
 
@@ -459,7 +455,7 @@ mod tests {
 
         #[tokio::test]
         #[traced_test]
-        async fn local_swarm_discovery_subscribe() -> TestResult {
+        async fn mdns_subscribe() -> TestResult {
             let num_nodes = 5;
             let mut node_ids = BTreeSet::new();
             let mut discoverers = vec![];
@@ -499,9 +495,9 @@ mod tests {
             Ok(())
         }
 
-        fn make_discoverer() -> Result<(PublicKey, LocalSwarmDiscovery)> {
+        fn make_discoverer() -> Result<(PublicKey, MdnsDiscovery)> {
             let node_id = SecretKey::generate(rand::thread_rng()).public();
-            Ok((node_id, LocalSwarmDiscovery::new(node_id)?))
+            Ok((node_id, MdnsDiscovery::new(node_id)?))
         }
     }
 }

iroh/src/endpoint.rs

@@ -385,14 +385,14 @@ impl Builder {
     #[cfg(feature = "discovery-local-network")]
     /// Configures the endpoint to also use local network discovery.
     ///
-    /// This is equivalent to adding a [`crate::discovery::local_swarm_discovery::LocalSwarmDiscovery`]
-    /// with default settings. Note that LocalSwarmDiscovery has various more advanced
+    /// This is equivalent to adding a [`crate::discovery::mdns::MdnsDiscovery`]
+    /// with default settings. Note that MdnsDiscovery has various more advanced
     /// configuration options. If you need any of those, you should manually
-    /// create a LocalSwarmDiscovery and add it with [`Builder::add_discovery`].
+    /// create a MdnsDiscovery and add it with [`Builder::add_discovery`].
     pub fn discovery_local_network(mut self) -> Self {
-        use crate::discovery::local_swarm_discovery::LocalSwarmDiscovery;
+        use crate::discovery::mdns::MdnsDiscovery;
         self.discovery.push(Box::new(|secret_key| {
-            LocalSwarmDiscovery::new(secret_key.public())
+            MdnsDiscovery::new(secret_key.public())
                 .map(|x| Box::new(x) as _)
                 .ok()
         }));
@@ -1011,7 +1011,7 @@ impl Endpoint {
     /// through [`Discovery::resolve`], which is invoked automatically when calling
     /// [`Endpoint::connect`] for a [`NodeId`] unknown to the endpoint. It also includes
     /// nodes that the endpoint discovers passively from discovery services that implement
-    /// [`Discovery::subscribe`], which e.g. [`LocalSwarmDiscovery`] does.
+    /// [`Discovery::subscribe`], which e.g. [`MdnsDiscovery`] does.
     ///
     /// The stream does not yield information about nodes that are added manually to the endpoint's
     /// addressbook by calling [`Endpoint::add_node_addr`] or by supplying a full [`NodeAddr`] to
@@ -1026,7 +1026,7 @@ impl Endpoint {
     /// See also [`Endpoint::remote_info_iter`], which returns an iterator over all remotes
     /// the endpoint knows about at a specific point in time.
     ///
-    /// [`LocalSwarmDiscovery`]: crate::discovery::local_swarm_discovery::LocalSwarmDiscovery
+    /// [`MdnsDiscovery`]: crate::discovery::mdns::MdnsDiscovery
     /// [`StaticProvider`]: crate::discovery::static_provider::StaticProvider
     pub fn discovery_stream(&self) -> impl Stream<Item = Result<DiscoveryItem, Lagged>> {
         self.msock.discovery_subscribers().subscribe()