refactor!: use a single DNS resolver (#3167)

## Description

We used to have more-or-less identical code in various places to set a
static DNS resolver and add a few extension methods on the
`hickory_resolver::TokioResolver`. This PR cleans this up and makes all
of iroh use the same resolver, defined in a single place, as a newtype
struct around the `TokioResolver` from `hickory_resolver`:

* Adds a newtype struct `DnsResolver` around
`hickory_resolver::TokioResolver` in `iroh_relay::dns`. It lives (for
now) in `iroh_relay`, because this is a the bottom of our dependency
chain: both `iroh` and `iroh-net-report` need to use it as well, and
both depend on `iroh_relay`.
* Adds most methods from the previous extension traits to the
`DnsResolver` struct
* Changes all imports to use this `DnsResolver` now instead of the
previous type alias to TokioResolver
* Removes all now-obsolete duplicate extension traits and type aliases
and duplicated tests
* Removes the global `static` DnsResolver that was accessible via
`iroh::dns::default_resolver`. This means that by default multiple
endpoints in the same app would not share the DnsResolver. However, I'd
say a) it is not too common to use multiple endpoints, and b) if you do
and want to share the DnsResolver, you can still do so by creating the
DnsResolver yourself and cloning it into the endpoint builder.
* Cleans up and aligns the various methods on `DnsResolver`, and newtype
the types from hickory so that this public iroh API does not depend on
hickory types (apart from a `From<TokioResolver> for DnsResolver`, which
is deferred to a follow-up to investigate)


The only place outside of tests and examples where a new `DnsResolver`
is constructed is in endpoint builder if no custom DnsResolver is set.
This means: As long as an app has a single endpoint only, there will
only be one DnsResolver.


## Breaking Changes

* `iroh::dns::resolver` and `iroh::dns::default_resolver` are removed.
There is no static, global DNS resolver anymore. If you want to share a
DNS resolver between endpoints, create the resolver yourself with
`iroh::dns::DnsResolver::new` and clone it into the endpoint builders
(in `EndpointBuilder::dns_resolver`). If you want to reuse the DNS
resolver from an endpoint, you can access it with
`Endpoint::dns_resolver` and clone it to wherever you need it.
* `iroh::dns::DnsResolver` used to be a type alias and now is a reexport
of `iroh_relay::dns::DnsResolver` struct
* `iroh::dns::node_info` module is now a reexport of
`iroh_relay::dns::node_info`
* `iroh::dns::node_info::{IrohAttr, TxtAttrs,
node_id_from_hickory_name}` are no longer public. Use
`iroh::dns::DnsResolver::lookup_node_by_id` or
`iroh::dns::DnsResolver::lookup_node_by_domain_name` to lookup node info
from DNS.
* `iroh::dns::node_info::{to_z32, from_z32}`are removed. Use the methods
on `iroh::dns::node_info::NodeIdExt` trait instead.
* `iroh::discovery::dns::{N0_DNS_NODE_ORIGIN_PROD,
N0_DNS_NODE_ORIGIN_STAGING}` are now reexports of
`iroh_relay::dns::{N0_DNS_NODE_ORIGIN_PROD, N0_DNS_NODE_ORIGIN_STAGING}`
* `iroh::dns::ResolverExt` is removed. Use the methods on
`iroh::dns::DnsResolver` instead.
* The methods in `iroh::dns::DnsResolver` now take an `impl ToString`
instead of `impl hickory_proto::rr::domain::IntoName` for their `host`
argument

* `iroh::test_utils::create_dns_resolver` is removed, use
`iroh::dns::DnsResolver::new` instead

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist

- [x] Self-review.
- [x] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [x] All breaking changes documented.

Author: Frando

Cargo.lock

@@ -7,7 +7,7 @@ use iroh::{
         dns::{N0_DNS_NODE_ORIGIN_PROD, N0_DNS_NODE_ORIGIN_STAGING},
         pkarr::{PkarrRelayClient, N0_DNS_PKARR_RELAY_PROD, N0_DNS_PKARR_RELAY_STAGING},
     },
-    dns::node_info::{to_z32, NodeInfo, IROH_TXT_NAME},
+    dns::node_info::{NodeIdExt, NodeInfo, IROH_TXT_NAME},
     NodeId, SecretKey,
 };
 use url::Url;
@@ -117,5 +117,5 @@ async fn main() -> Result<()> {
 }
 
 fn fmt_domain(node_id: &NodeId, origin: &str) -> String {
-    format!("{}.{}.{}", IROH_TXT_NAME, to_z32(node_id), origin)
+    format!("{}.{}.{}", IROH_TXT_NAME, node_id.to_z32(), origin)
 }

iroh-dns-server/examples/publish.rs

@@ -1,14 +1,7 @@
-use std::net::SocketAddr;
-
 use clap::{Parser, ValueEnum};
-use hickory_resolver::{
-    config::{NameServerConfig, ResolverConfig},
-    proto::xfer::Protocol,
-    Resolver,
-};
 use iroh::{
     discovery::dns::{N0_DNS_NODE_ORIGIN_PROD, N0_DNS_NODE_ORIGIN_STAGING},
-    dns::{node_info::TxtAttrs, DnsResolver},
+    dns::DnsResolver,
     NodeId,
 };
 
@@ -46,39 +39,23 @@ enum Command {
 async fn main() -> anyhow::Result<()> {
     let args = Cli::parse();
     let (resolver, origin) = match args.env {
-        Env::Staging => (
-            iroh::dns::default_resolver().clone(),
-            N0_DNS_NODE_ORIGIN_STAGING,
-        ),
-        Env::Prod => (
-            iroh::dns::default_resolver().clone(),
-            N0_DNS_NODE_ORIGIN_PROD,
-        ),
+        Env::Staging => (DnsResolver::new(), N0_DNS_NODE_ORIGIN_STAGING),
+        Env::Prod => (DnsResolver::new(), N0_DNS_NODE_ORIGIN_PROD),
         Env::Dev => (
-            resolver_with_nameserver(LOCALHOST_DNS.parse()?),
+            DnsResolver::with_nameserver(LOCALHOST_DNS.parse()?),
             EXAMPLE_ORIGIN,
         ),
     };
     let resolved = match args.command {
-        Command::Node { node_id } => {
-            TxtAttrs::<String>::lookup_by_id(&resolver, &node_id, origin).await?
-        }
-        Command::Domain { domain } => {
-            TxtAttrs::<String>::lookup_by_name(&resolver, &domain).await?
-        }
+        Command::Node { node_id } => resolver.lookup_node_by_id(&node_id, origin).await?,
+        Command::Domain { domain } => resolver.lookup_node_by_domain_name(&domain).await?,
     };
-    println!("resolved node {}", resolved.node_id());
-    for (key, values) in resolved.attrs() {
-        for value in values {
-            println!("    {key}={value}");
-        }
+    println!("resolved node {}", resolved.node_id);
+    if let Some(url) = resolved.relay_url {
+        println!("    relay={url}")
+    }
+    for addr in resolved.direct_addresses {
+        println!("    addr={addr}")
     }
     Ok(())
 }
-
-fn resolver_with_nameserver(nameserver: SocketAddr) -> DnsResolver {
-    let mut config = ResolverConfig::new();
-    let nameserver_config = NameServerConfig::new(nameserver, Protocol::Udp);
-    config.add_name_server(nameserver_config);
-    Resolver::tokio(config, Default::default())
-}

iroh-dns-server/examples/resolve.rs

@@ -22,14 +22,9 @@ mod tests {
     };
 
     use anyhow::Result;
-    use hickory_resolver::{
-        config::{NameServerConfig, ResolverConfig},
-        Resolver,
-    };
-    use hickory_server::proto::xfer::Protocol;
     use iroh::{
         discovery::pkarr::PkarrRelayClient,
-        dns::{node_info::NodeInfo, DnsResolver, ResolverExt},
+        dns::{node_info::NodeInfo, DnsResolver},
         SecretKey,
     };
     use pkarr::{PkarrClient, SignedPacket};
@@ -45,6 +40,8 @@ mod tests {
         ZoneStore,
     };
 
+    const DNS_TIMEOUT: Duration = Duration::from_secs(1);
+
     #[tokio::test]
     #[traced_test]
     async fn pkarr_publish_dns_resolve() -> Result<()> {
@@ -120,38 +117,38 @@ mod tests {
 
         // resolve root record
         let name = Name::from_utf8(format!("{pubkey}."))?;
-        let res = resolver.txt_lookup(name).await?;
-        let records = res.iter().map(|t| t.to_string()).collect::<Vec<_>>();
+        let res = resolver.lookup_txt(name, DNS_TIMEOUT).await?;
+        let records = res.into_iter().map(|t| t.to_string()).collect::<Vec<_>>();
         assert_eq!(records, vec!["hi0".to_string()]);
 
         // resolve level one record
         let name = Name::from_utf8(format!("_hello.{pubkey}."))?;
-        let res = resolver.txt_lookup(name).await?;
-        let records = res.iter().map(|t| t.to_string()).collect::<Vec<_>>();
+        let res = resolver.lookup_txt(name, DNS_TIMEOUT).await?;
+        let records = res.into_iter().map(|t| t.to_string()).collect::<Vec<_>>();
         assert_eq!(records, vec!["hi1".to_string()]);
 
         // resolve level two record
         let name = Name::from_utf8(format!("_hello.world.{pubkey}."))?;
-        let res = resolver.txt_lookup(name).await?;
-        let records = res.iter().map(|t| t.to_string()).collect::<Vec<_>>();
+        let res = resolver.lookup_txt(name, DNS_TIMEOUT).await?;
+        let records = res.into_iter().map(|t| t.to_string()).collect::<Vec<_>>();
         assert_eq!(records, vec!["hi2".to_string()]);
 
         // resolve multiple records for same name
         let name = Name::from_utf8(format!("multiple.{pubkey}."))?;
-        let res = resolver.txt_lookup(name).await?;
-        let records = res.iter().map(|t| t.to_string()).collect::<Vec<_>>();
+        let res = resolver.lookup_txt(name, DNS_TIMEOUT).await?;
+        let records = res.into_iter().map(|t| t.to_string()).collect::<Vec<_>>();
         assert_eq!(records, vec!["hi3".to_string(), "hi4".to_string()]);
 
         // resolve A record
         let name = Name::from_utf8(format!("{pubkey}."))?;
-        let res = resolver.ipv4_lookup(name).await?;
-        let records = res.iter().map(|t| t.0).collect::<Vec<_>>();
+        let res = resolver.lookup_ipv4(name, DNS_TIMEOUT).await?;
+        let records = res.collect::<Vec<_>>();
         assert_eq!(records, vec![Ipv4Addr::LOCALHOST]);
 
         // resolve AAAA record
         let name = Name::from_utf8(format!("foo.bar.baz.{pubkey}."))?;
-        let res = resolver.ipv6_lookup(name).await?;
-        let records = res.iter().map(|t| t.0).collect::<Vec<_>>();
+        let res = resolver.lookup_ipv6(name, DNS_TIMEOUT).await?;
+        let records = res.collect::<Vec<_>>();
         assert_eq!(records, vec![Ipv6Addr::LOCALHOST]);
 
         server.shutdown().await?;
@@ -181,7 +178,7 @@ mod tests {
         pkarr.publish(&signed_packet).await?;
 
         let resolver = test_resolver(nameserver);
-        let res = resolver.lookup_by_id(&node_id, origin).await?;
+        let res = resolver.lookup_node_by_id(&node_id, origin).await?;
 
         assert_eq!(res.node_id, node_id);
         assert_eq!(res.relay_url.map(Url::from), Some(relay_url));
@@ -252,7 +249,7 @@ mod tests {
 
         // resolve via DNS from our server, which will lookup from our DHT
         let resolver = test_resolver(nameserver);
-        let res = resolver.lookup_by_id(&node_id, origin).await?;
+        let res = resolver.lookup_node_by_id(&node_id, origin).await?;
 
         assert_eq!(res.node_id, node_id);
         assert_eq!(res.relay_url.map(Url::from), Some(relay_url));
@@ -265,10 +262,7 @@ mod tests {
     }
 
     fn test_resolver(nameserver: SocketAddr) -> DnsResolver {
-        let mut config = ResolverConfig::new();
-        let nameserver_config = NameServerConfig::new(nameserver, Protocol::Udp);
-        config.add_name_server(nameserver_config);
-        Resolver::tokio(config, Default::default())
+        DnsResolver::with_nameserver(nameserver)
     }
 
     fn random_signed_packet() -> Result<SignedPacket> {