style: cargo fmt

benches/recursive_compare.rs

@@ -610,8 +610,10 @@ fn run_hedge_multi(rt: &tokio::runtime::Runtime, iterations: usize) {
     );
 
     let primary = numa::forward::parse_upstream(DOH_UPSTREAM, 443, None).expect("failed to parse");
-    let primary_dual = numa::forward::parse_upstream(DOH_UPSTREAM, 443, None).expect("failed to parse");
+    let primary_dual =
-    let secondary_dual = numa::forward::parse_upstream(DOH_UPSTREAM, 443, None).expect("failed to parse");
+        numa::forward::parse_upstream(DOH_UPSTREAM, 443, None).expect("failed to parse");
+    let secondary_dual =
+        numa::forward::parse_upstream(DOH_UPSTREAM, 443, None).expect("failed to parse");
     let resolver = rt.block_on(build_hickory_resolver());
 
     println!("Warming up...");

src/bootstrap_resolver.rs

@@ -87,15 +87,12 @@ impl Resolve for NumaResolver {
         let hostname = name.as_str().to_string();
 
         if let Some(ips) = self.overrides.get(&hostname) {
-            let addrs: Vec<SocketAddr> =
+            let addrs: Vec<SocketAddr> = ips.iter().map(|ip| SocketAddr::new(*ip, 0)).collect();
-                ips.iter().map(|ip| SocketAddr::new(*ip, 0)).collect();
             debug!(
                 "bootstrap_resolver: override hit for {} → {:?}",
                 hostname, ips
             );
-            return Box::pin(
+            return Box::pin(async move { Ok(Box::new(addrs.into_iter()) as Addrs) });
-                async move { Ok(Box::new(addrs.into_iter()) as Addrs) },
-            );
         }
 
         let bootstrap = self.bootstrap.clone();
@@ -144,7 +141,10 @@ async fn resolve_via_bootstrap(
         .into())
 }
 
-async fn query_with_tcp_fallback(query: &DnsPacket, server: SocketAddr) -> crate::Result<DnsPacket> {
+async fn query_with_tcp_fallback(
+    query: &DnsPacket,
+    server: SocketAddr,
+) -> crate::Result<DnsPacket> {
     match forward_udp(query, server, UDP_TIMEOUT).await {
         Ok(pkt) => Ok(pkt),
         Err(e) => {

src/ctx.rs

@@ -210,12 +210,8 @@ pub async fn resolve_query(
                 // Conditional forwarding takes priority over recursive mode
                 // (e.g. Tailscale .ts.net, VPC private zones)
                 let key = (qname.clone(), qtype);
-                let (resp, path, err) = resolve_coalesced(
+                let (resp, path, err) =
-                    &ctx.inflight,
+                    resolve_coalesced(&ctx.inflight, key, &query, QueryPath::Forwarded, || async {
-                    key,
-                    &query,
-                    QueryPath::Forwarded,
-                    || async {
                         let wire = forward_with_failover_raw(
                             raw_wire,
                             pool,
@@ -225,9 +221,8 @@ pub async fn resolve_query(
                         )
                         .await?;
                         cache_and_parse(ctx, &qname, qtype, &wire)
-                    },
+                    })
-                )
+                    .await;
-                .await;
                 log_coalesced_outcome(src_addr, qtype, &qname, path, err.as_deref(), "FORWARD");
                 if path == QueryPath::Forwarded {
                     upstream_transport = pool.preferred().map(|u| u.transport());
@@ -238,12 +233,8 @@ pub async fn resolve_query(
                 // tag as Udp so the dashboard can aggregate plaintext-wire
                 // egress honestly. Only mark on success — errors stay None.
                 let key = (qname.clone(), qtype);
-                let (resp, path, err) = resolve_coalesced(
+                let (resp, path, err) =
-                    &ctx.inflight,
+                    resolve_coalesced(&ctx.inflight, key, &query, QueryPath::Recursive, || {
-                    key,
-                    &query,
-                    QueryPath::Recursive,
-                    || {
                         crate::recursive::resolve_recursive(
                             &qname,
                             qtype,
@@ -252,9 +243,8 @@ pub async fn resolve_query(
                             &ctx.root_hints,
                             &ctx.srtt,
                         )
-                    },
+                    })
-                )
+                    .await;
-                .await;
                 log_coalesced_outcome(src_addr, qtype, &qname, path, err.as_deref(), "RECURSIVE");
                 if path == QueryPath::Recursive {
                     upstream_transport = Some(crate::stats::UpstreamTransport::Udp);
@@ -263,12 +253,8 @@ pub async fn resolve_query(
             } else {
                 let pool = ctx.upstream_pool.lock().unwrap().clone();
                 let key = (qname.clone(), qtype);
-                let (resp, path, err) = resolve_coalesced(
+                let (resp, path, err) =
-                    &ctx.inflight,
+                    resolve_coalesced(&ctx.inflight, key, &query, QueryPath::Upstream, || async {
-                    key,
-                    &query,
-                    QueryPath::Upstream,
-                    || async {
                         let wire = forward_with_failover_raw(
                             raw_wire,
                             &pool,
@@ -278,9 +264,8 @@ pub async fn resolve_query(
                         )
                         .await?;
                         cache_and_parse(ctx, &qname, qtype, &wire)
-                    },
+                    })
-                )
+                    .await;
-                .await;
                 log_coalesced_outcome(src_addr, qtype, &qname, path, err.as_deref(), "UPSTREAM");
                 if path == QueryPath::Upstream {
                     upstream_transport = pool.preferred().map(|u| u.transport());

src/forward.rs

@@ -113,10 +113,7 @@ impl fmt::Display for Upstream {
     }
 }
 
-pub fn parse_upstream_addr(
+pub fn parse_upstream_addr(s: &str, default_port: u16) -> std::result::Result<SocketAddr, String> {
-    s: &str,
-    default_port: u16,
-) -> std::result::Result<SocketAddr, String> {
     // Try full socket addr first: "1.2.3.4:5353" or "[::1]:5353"
     if let Ok(addr) = s.parse::<SocketAddr>() {
         return Ok(addr);

src/serve.rs

@@ -18,7 +18,9 @@ use crate::buffer::BytePacketBuffer;
 use crate::cache::DnsCache;
 use crate::config::{build_zone_map, load_config, ConfigLoad};
 use crate::ctx::{handle_query, ServerCtx};
-use crate::forward::{build_https_client_with_resolver, parse_upstream_list, Upstream, UpstreamPool};
+use crate::forward::{
+    build_https_client_with_resolver, parse_upstream_list, Upstream, UpstreamPool,
+};
 use crate::odoh::OdohConfigCache;
 use crate::override_store::OverrideStore;
 use crate::query_log::QueryLog;
@@ -625,11 +627,7 @@ async fn network_watch_loop(ctx: Arc<ServerCtx>) {
     }
 }
 
-async fn load_blocklists(
+async fn load_blocklists(ctx: &ServerCtx, lists: &[String], resolver: Option<Arc<NumaResolver>>) {
-    ctx: &ServerCtx,
-    lists: &[String],
-    resolver: Option<Arc<NumaResolver>>,
-) {
     let downloaded = download_blocklists(lists, resolver).await;
 
     // Parse outside the lock to avoid blocking DNS queries during parse (~100ms)