chore: update to hickory =0.25.0-alpha.4 (#3021)

## Description

Update hickory to 0.25.0-alpha.4 and try to get the code to compile
again. Hopefully the API won't change that much from this to the next
non-alpha release 0.25
hickory-dns/hickory-dns#2206 (comment)
.

## Breaking Changes

None

## Notes & open questions

Note: we still trigger cargo-deny because of the swarm-discovery crate:
https://github.com/rkuhn/swarm-discovery/blob/master/Cargo.toml#L20

I guess even once we have merged this we still have to add an exemption
to the deny.toml

Is the usage of the new API correct, specifically regarding the new
LookupControlFlow enum.

It seems from the doc that I should just take the existing code and wrap
it in LookupControlFlow::Continue?

```rust

/// Result of a Lookup in the Catalog and Authority
///
/// * **All authorities should default to using LookupControlFlow::Continue to wrap their responses.**
///   These responses may be passed to other authorities for analysis or requery purposes.
/// * Authorities may use LookupControlFlow::Break to indicate the response must be returned
///   immediately to the client, without consulting any other authorities.  For example, if the
///   the user configures a blocklist authority, it would not be appropriate to pass the query to
///   any additional authorities to try to resolve, as that might be used to leak information to a
///   hostile party, and so a blocklist (or similar) authority should wrap responses for any
///   blocklist hits in LookupControlFlow::Break.
/// * Authorities may use LookupControlFlow::Skip to indicate the authority did not attempt to
///   process a particular query.  This might be used, for example, in a block list authority for
///   any queries that **did not** match the blocklist, to allow the recursor or forwarder to
///   resolve the query. Skip must not be used to represent an empty lookup; (use
///   Continue(EmptyLookup) or Break(EmptyLookup) for that.)
pub enum LookupControlFlow<T, E = LookupError> {
    /// A lookup response that may be passed to one or more additional authorities before
    /// being returned to the client.
    Continue(Result<T, E>),
    /// A lookup response that must be immediately returned to the client without consulting
    /// any other authorities.
    Break(Result<T, E>),
    /// The authority did not answer the query and the next authority in the chain should
    /// be consulted.
    Skip,
}
```

## Change checklist

- [ ] Self-review.
- [ ] 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.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.

Author: rklaehn

Cargo.lock

@@ -26,4 +26,5 @@ license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
 ignore = [
     "RUSTSEC-2024-0370", # unmaintained, no upgrade available
     "RUSTSEC-2024-0384", # unmaintained, no upgrade available
+    "RUSTSEC-2024-0421", # dependency from swarm-discovery, see https://github.com/rkuhn/swarm-discovery/issues/9
 ]

deny.toml

@@ -26,8 +26,7 @@ derive_more = { version = "1.0.0", features = [
 dirs-next = "2.0.0"
 futures-lite = "2.5"
 governor = "0.6.3" #needs new release of tower_governor for 0.7.0
-hickory-proto = "=0.25.0-alpha.2"
-hickory-server = { version = "=0.25.0-alpha.2", features = ["dns-over-rustls"] }
+hickory-server = { version = "=0.25.0-alpha.4", features = ["dns-over-rustls", "dns-over-https-rustls"] }
 http = "1.0.0"
 humantime-serde = "1.1.1"
 iroh-metrics = { version = "0.29.0" }
@@ -61,7 +60,7 @@ z32 = "1.1.1"
 
 [dev-dependencies]
 criterion = "0.5.1"
-hickory-resolver = "=0.25.0-alpha.2"
+hickory-resolver = "=0.25.0-alpha.4"
 iroh = { version = "0.29.0", path = "../iroh" }
 iroh-test = { version = "0.29.0", path = "../iroh-test" }
 pkarr = { version = "2.2.0", features = ["rand"] }

iroh-dns-server/Cargo.toml

@@ -2,8 +2,9 @@ use std::net::SocketAddr;
 
 use clap::{Parser, ValueEnum};
 use hickory_resolver::{
-    config::{NameServerConfig, Protocol, ResolverConfig},
-    AsyncResolver,
+    config::{NameServerConfig, ResolverConfig},
+    proto::xfer::Protocol,
+    Resolver,
 };
 use iroh::{
     discovery::dns::{N0_DNS_NODE_ORIGIN_PROD, N0_DNS_NODE_ORIGIN_STAGING},
@@ -79,5 +80,5 @@ 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);
-    AsyncResolver::tokio(config, Default::default())
+    Resolver::tokio(config, Default::default())
 }

iroh-dns-server/examples/resolve.rs

@@ -14,19 +14,19 @@ use bytes::Bytes;
 use hickory_server::{
     authority::{Catalog, MessageResponse, ZoneType},
     proto::{
+        self,
+        op::ResponseCode,
         rr::{
             rdata::{self},
-            RData, Record, RecordSet, RecordType, RrKey,
+            LowerName, Name, RData, Record, RecordSet, RecordType, RrKey,
         },
         serialize::{binary::BinEncoder, txt::RDataParser},
-        {self},
+        xfer::Protocol,
     },
-    resolver::Name,
     server::{Request, RequestHandler, ResponseHandler, ResponseInfo},
     store::in_memory::InMemoryAuthority,
 };
 use iroh_metrics::inc;
-use proto::{op::ResponseCode, rr::LowerName};
 use serde::{Deserialize, Serialize};
 use tokio::{
     net::{TcpListener, UdpSocket},
@@ -135,12 +135,16 @@ impl DnsHandler {
             .collect::<Result<Vec<_>, _>>()?;
 
         let (static_authority, serial) = create_static_authority(&origins, config)?;
-        let authority = NodeAuthority::new(zone_store, static_authority, origins, serial)?;
-        let authority = Arc::new(authority);
+        let authority = Arc::new(NodeAuthority::new(
+            zone_store,
+            static_authority,
+            origins,
+            serial,
+        )?);
 
         let mut catalog = Catalog::new();
         for origin in authority.origins() {
-            catalog.upsert(LowerName::from(origin), Box::new(Arc::clone(&authority)));
+            catalog.upsert(LowerName::from(origin), vec![authority.clone()]);
         }
 
         Ok(Self {
@@ -166,8 +170,8 @@ impl RequestHandler for DnsHandler {
     ) -> ResponseInfo {
         inc!(Metrics, dns_requests);
         match request.protocol() {
-            hickory_server::server::Protocol::Udp => inc!(Metrics, dns_requests_udp),
-            hickory_server::server::Protocol::Https => inc!(Metrics, dns_requests_https),
+            Protocol::Udp => inc!(Metrics, dns_requests_udp),
+            Protocol::Https => inc!(Metrics, dns_requests_https),
             _ => {}
         }
         debug!(protocol=%request.protocol(), query=%request.query(), "incoming DNS request");
@@ -266,7 +270,7 @@ fn create_static_authority(
 
 fn push_record(records: &mut BTreeMap<RrKey, RecordSet>, serial: u32, record: Record) {
     let key = RrKey::new(record.name().clone().into(), record.record_type());
-    let mut record_set = RecordSet::new(record.name(), record.record_type(), serial);
+    let mut record_set = RecordSet::new(record.name().clone(), record.record_type(), serial);
     record_set.insert(record, serial);
     records.insert(key, record_set);
 }