feat(iroh-net)!: improve dns behaviour by staggering requests (#2313)

## Description

Improves dns behaviour by staggering concurrent queries. Other changes
include:
- Remove unnecessary trait bounds from `ResolverExt` functions.
- Unify dns capabilities under `ResolverExt`.
- Add helper fn `stagger_call` with a minimal test.
- Add staggering versions of the `ResolverExt` functions.
- Use staggered options and turn on tests

## Breaking Changes

- `iroh_net::dns::node_info::lookup_by_domain` moved to
`iroh_net::ResolverExt::lookup_by_domain`

## Notes & open questions

Whether test are less prone to fail randomly is something I can't test
locally (no windows) so I'm trusting ci here.

## Change checklist

- [x] Self-review.
- [x] Documentation updates if relevant.
- [x] Tests if relevant.
- [x] All breaking changes documented.

iroh-dns-server/examples/resolve.rs

@@ -57,7 +57,7 @@ async fn main() -> anyhow::Result<()> {
             TxtAttrs::<String>::lookup_by_id(&resolver, &node_id, origin).await?
         }
         Command::Domain { domain } => {
-            TxtAttrs::<String>::lookup_by_domain(&resolver, &domain).await?
+            TxtAttrs::<String>::lookup_by_name(&resolver, &domain).await?
         }
     };
     println!("resolved node {}", resolved.node_id());

iroh-dns-server/src/lib.rs

@@ -22,10 +22,7 @@ mod tests {
     };
     use iroh_net::{
         discovery::pkarr_publish::PkarrRelayClient,
-        dns::{
-            node_info::{lookup_by_id, NodeInfo},
-            DnsResolver,
-        },
+        dns::{node_info::NodeInfo, DnsResolver, ResolverExt},
         key::SecretKey,
     };
     use pkarr::{PkarrClient, SignedPacket};
@@ -168,7 +165,7 @@ mod tests {
         pkarr.publish(&signed_packet).await?;
 
         let resolver = test_resolver(nameserver);
-        let res = lookup_by_id(&resolver, &node_id, origin).await?;
+        let res = resolver.lookup_by_id(&node_id, origin).await?;
 
         assert_eq!(res.node_id, node_id);
         assert_eq!(res.info.relay_url.map(Url::from), Some(relay_url));
@@ -204,7 +201,7 @@ mod tests {
 
         // resolve via DNS from our server, which will lookup from our DHT
         let resolver = test_resolver(nameserver);
-        let res = lookup_by_id(&resolver, &node_id, origin).await?;
+        let res = resolver.lookup_by_id(&node_id, origin).await?;
 
         assert_eq!(res.node_id, node_id);
         assert_eq!(res.info.relay_url.map(Url::from), Some(relay_url));

iroh-net/src/discovery.rs

@@ -562,7 +562,7 @@ mod test_dns_pkarr {
 
     use crate::{
         discovery::pkarr_publish::PkarrPublisher,
-        dns::node_info::{lookup_by_id, NodeInfo},
+        dns::{node_info::NodeInfo, ResolverExt},
         relay::{RelayMap, RelayMode},
         test_utils::{
             dns_server::{create_dns_resolver, run_dns_server},
@@ -590,7 +590,7 @@ mod test_dns_pkarr {
         state.upsert(signed_packet)?;
 
         let resolver = create_dns_resolver(nameserver)?;
-        let resolved = lookup_by_id(&resolver, &node_info.node_id, &origin).await?;
+        let resolved = resolver.lookup_by_id(&node_info.node_id, &origin).await?;
 
         assert_eq!(resolved, node_info.into());
 
@@ -620,7 +620,7 @@ mod test_dns_pkarr {
         publisher.update_addr_info(&addr_info);
         // wait until our shared state received the update from pkarr publishing
         dns_pkarr_server.on_node(&node_id, timeout).await?;
-        let resolved = lookup_by_id(&resolver, &node_id, &origin).await?;
+        let resolved = resolver.lookup_by_id(&node_id, &origin).await?;
 
         let expected = NodeAddr {
             info: addr_info,

iroh-net/src/discovery/dns.rs

@@ -5,11 +5,13 @@ use futures_lite::stream::Boxed as BoxStream;
 
 use crate::{
     discovery::{Discovery, DiscoveryItem},
-    dns, Endpoint, NodeId,
+    dns::ResolverExt,
+    Endpoint, NodeId,
 };
 
 /// The n0 testing DNS node origin
 pub const N0_DNS_NODE_ORIGIN: &str = "dns.iroh.link";
+const DNS_STAGGERING_MS: &[u64] = &[200, 300];
 
 /// DNS node discovery
 ///
@@ -53,8 +55,9 @@ impl Discovery for DnsDiscovery {
         let resolver = ep.dns_resolver().clone();
         let origin_domain = self.origin_domain.clone();
         let fut = async move {
-            let node_addr =
-                dns::node_info::lookup_by_id(&resolver, &node_id, &origin_domain).await?;
+            let node_addr = resolver
+                .lookup_by_id_staggered(&node_id, &origin_domain, DNS_STAGGERING_MS)
+                .await?;
             Ok(DiscoveryItem {
                 provenance: "dns",
                 last_updated: None,