refactor(iroh)!: Add IntoDiscovery trait (#3327)

## Description

Discovery services may want to access the endpoint they are attached to
for various reasons.
* Currently, we pass a reference to the `&Endpoint` in
`Discovery::resolve`, but not in `Discovery::publish`.
* All pkarr-based publishers need access to the endpoint's secret key
for signing packets. For this reason, we allow passing a closure to
`endpoint::Builder::add_discovery` that gets the secret key as an
argument
* The pkarr publisher *should* get hold of the endpoint's DNS resolver
to resolve the pkarr relay URL (but doesn't atm, which is a bug - it
uses reqwest's default resolver, always)

So this PR changes the construction by adding an `IntoDiscovery` trait
with a single method `into_discovery(self, context: &DiscoveryContext)
-> impl Discovery`. And `endpoint::Builder::add_discovery` now takes any
`IntoDiscovery`. Through this, discovery service construction is a
two-step process where users create a builder and set any options
available, and then during endpoint building we call `into_discovery`
and pass a discovery context.

We can't pass a full endpoint to discovery services, because if they'd
clone it, the Endpoint could never be dropped due to a reference cycle:
`Endpoint -> Magicsock -> Box<dyn Discovery> -> Endpoint`. Therefore,
this PR adds a `DiscoveryContext` struct that contains the endpoint's
secret key and DNS resolver. We can add more things later, if needed.

There's also a blanket impl of `IntoDiscovery` for any `T: Discovery`,
so discovery services that do not need an endpoint can skip the builder
and don't have to implement `IntoDiscovery` manually at all, users can
just pass the constructed discovery struct to `Endpoint::add_discovery`.

This means *writing* discovery services is a little bit more involved,
as you have to create a builder and implement a second trait. However,
writing discovery services is a rather rare task, and with good docs the
additional work is very minor. On the upside, this creates a clean way
for discovery services to access the endpoint they are mounted on, which
also opens the door for discovery services using iroh itself.

## Breaking Changes

Changed:
* `iroh::endpoint::Builder::add_discovery` now takes an `impl
iroh::discovery::IntoDiscovery` argument instead of a closure that
returns a `Discovery`. You can implement that on a builder struct, and
any `T: Discovery` has an auto-impl of `IntoDiscovery`.
* `iroh::discovery::Discovery::resolve` no longer gets a `&Endpoint`
argument. If you need an endpoint in your discovery service, add a
builder struct and implement `IntoDiscovery` for it, which gives you an
endpoint that you can clone into your service
* Removed `iroh::discovery::dns::DnsDiscovery::new`, use
`DnsDiscovery::builder` instead
* Removed `iroh::discovery::pkarr::PkarrPublisher::new`, use
`PkarrPublisher::builder` instead
* Removed `iroh::discovery::pkarr::PkarrPublisher::with_options`, use
`PkarrPublisher::builder` instead
* Removed `iroh::discovery::pkarr::PkarrResolver::new`, use
`PkarrResolver::builder` instead
* `iroh::discovery::pkarr::PkarrPublisher::n0_dns` now takes no
arguments and returns a `PkarrPublisherBuilder`. The secret key is set
on `PkarrPublisherBuilder::build` instead.

## Notes & open questions

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

## Change checklist
<!-- Remove any that are not relevant. -->
- [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] Tests if relevant.
- [x] All breaking changes documented.
- [x] List all breaking changes in the above "Breaking Changes" section.
- [ ] Open an issue or PR on any number0 repos that are affected by this
breaking change. Give guidance on how the updates should be handled or
do the actual updates themselves. The major ones are:
    - [ ] [`quic-rpc`](https://github.com/n0-computer/quic-rpc)
    - [ ] [`iroh-gossip`](https://github.com/n0-computer/iroh-gossip)
    - [ ] [`iroh-blobs`](https://github.com/n0-computer/iroh-blobs)
    - [ ] [`dumbpipe`](https://github.com/n0-computer/dumbpipe)
    - [ ] [`sendme`](https://github.com/n0-computer/sendme)

Author: Frando

iroh-relay/src/dns.rs

@@ -18,7 +18,10 @@ use snafu::{Backtrace, GenerateImplicitData, OptionExt, Snafu};
 use tokio::sync::RwLock;
 use url::Url;
 
-use crate::node_info::{LookupError, NodeInfo};
+use crate::{
+    defaults::timeouts::DNS_TIMEOUT,
+    node_info::{LookupError, NodeInfo},
+};
 
 /// The n0 testing DNS node origin, for production.
 pub const N0_DNS_NODE_ORIGIN_PROD: &str = "dns.iroh.link";
@@ -392,6 +395,27 @@ impl From<TokioResolver> for DnsResolver {
     }
 }
 
+impl reqwest::dns::Resolve for DnsResolver {
+    fn resolve(&self, name: reqwest::dns::Name) -> reqwest::dns::Resolving {
+        let this = self.clone();
+        let name = name.as_str().to_string();
+        Box::pin(async move {
+            let res = this.lookup_ipv4_ipv6(name, DNS_TIMEOUT).await;
+            match res {
+                Ok(addrs) => {
+                    let addrs: reqwest::dns::Addrs =
+                        Box::new(addrs.map(|addr| SocketAddr::new(addr, 0)));
+                    Ok(addrs)
+                }
+                Err(err) => {
+                    let err: Box<dyn std::error::Error + Send + Sync> = Box::new(err);
+                    Err(err)
+                }
+            }
+        })
+    }
+}
+
 /// TXT records returned from [`DnsResolver::lookup_txt`]
 #[derive(Debug, Clone)]
 pub struct TxtLookup(pub(crate) hickory_resolver::lookup::TxtLookup);

iroh/examples/dht_discovery.rs

@@ -64,13 +64,11 @@ fn build_discovery(args: Args) -> iroh::discovery::pkarr::dht::Builder {
 async fn chat_server(args: Args) -> n0_snafu::Result<()> {
     let secret_key = iroh::SecretKey::generate(rand::rngs::OsRng);
     let node_id = secret_key.public();
-    let discovery = build_discovery(args)
-        .secret_key(secret_key.clone())
-        .build()?;
+    let discovery = build_discovery(args);
     let endpoint = Endpoint::builder()
         .alpns(vec![CHAT_ALPN.to_vec()])
         .secret_key(secret_key)
-        .discovery(Box::new(discovery))
+        .discovery(discovery)
         .bind()
         .await?;
     let zid = pkarr::PublicKey::try_from(node_id.as_bytes()).e()?.to_z32();
@@ -111,11 +109,11 @@ async fn chat_client(args: Args) -> n0_snafu::Result<()> {
     let secret_key = iroh::SecretKey::generate(rand::rngs::OsRng);
     let node_id = secret_key.public();
     // note: we don't pass a secret key here, because we don't need to publish our address, don't spam the DHT
-    let discovery = build_discovery(args).build()?;
+    let discovery = build_discovery(args).no_publish();
     // we do not need to specify the alpn here, because we are not going to accept connections
     let endpoint = Endpoint::builder()
         .secret_key(secret_key)
-        .discovery(Box::new(discovery))
+        .discovery(discovery)
         .bind()
         .await?;
     println!("We are {} and connecting to {}", node_id, remote_node_id);

iroh/examples/transfer.rs

@@ -207,25 +207,19 @@ impl EndpointArgs {
             let url = self
                 .pkarr_relay_url
                 .unwrap_or_else(|| self.env.pkarr_relay_url());
-            builder = builder
-                .add_discovery(|secret_key| Some(PkarrPublisher::new(secret_key.clone(), url)));
+            builder = builder.add_discovery(PkarrPublisher::builder(url));
         }
 
         if !self.no_dns_resolve {
             let domain = self
                 .dns_origin_domain
                 .unwrap_or_else(|| self.env.dns_origin_domain());
-            builder = builder.add_discovery(|_| Some(DnsDiscovery::new(domain)));
+            builder = builder.add_discovery(DnsDiscovery::builder(domain));
         }
 
         #[cfg(feature = "discovery-local-network")]
         if self.mdns {
-            builder = builder.add_discovery(|secret_key| {
-                Some(
-                    iroh::discovery::mdns::MdnsDiscovery::new(secret_key.public())
-                        .expect("Failed to create mDNS discovery"),
-                )
-            });
+            builder = builder.discovery_local_network();
         }
 
         #[cfg(feature = "test-utils")]