Skip to main content

rustnet_core/network/
dns.rs

1//! DNS resolver with background async resolution and caching.
2//!
3//! Provides non-blocking reverse DNS lookups with an LRU cache to avoid
4//! repeated lookups for the same IP address.
5
6use crate::network::bogon::{Scope, classify};
7use crossbeam::channel::{self, Receiver, Sender};
8use dashmap::DashMap;
9use dashmap::mapref::entry::Entry;
10use dns_lookup::lookup_addr;
11use log::debug;
12use std::net::IpAddr;
13use std::sync::atomic::{AtomicBool, Ordering};
14use std::sync::{Arc, Condvar, Mutex};
15use std::thread::{self, JoinHandle};
16use std::time::{Duration, Instant};
17
18/// Resolution state for a cached entry
19#[derive(Debug, Clone, Copy, PartialEq, Eq)]
20pub(crate) enum ResolutionState {
21    /// Resolution is in progress
22    Pending,
23    /// Resolution succeeded
24    Resolved,
25    /// Resolution failed
26    Failed,
27}
28
29#[derive(Debug, Clone, Copy)]
30struct ResolutionRequest {
31    ip: IpAddr,
32    reserved_at: Instant,
33}
34
35type Worker = Box<dyn FnOnce() + Send + 'static>;
36type StartupGate = Arc<(Mutex<Option<bool>>, Condvar)>;
37
38fn wait_for_startup(gate: &StartupGate) -> bool {
39    let (state, ready) = &**gate;
40    let mut state = state.lock().unwrap_or_else(|error| error.into_inner());
41    while state.is_none() {
42        state = ready.wait(state).unwrap_or_else(|error| error.into_inner());
43    }
44    state.unwrap_or(false)
45}
46
47fn release_startup_gate(gate: &StartupGate, start: bool) {
48    let (state, ready) = &**gate;
49    *state.lock().unwrap_or_else(|error| error.into_inner()) = Some(start);
50    ready.notify_all();
51}
52
53/// Cached hostname entry
54#[derive(Debug, Clone)]
55pub(crate) struct CachedHostname {
56    /// The resolved hostname, if successful
57    pub hostname: Option<String>,
58    /// When this entry was resolved
59    pub resolved_at: Instant,
60    /// Current resolution state
61    pub state: ResolutionState,
62}
63
64/// How long a `Pending` entry is trusted before the lookup is considered
65/// lost and the address may be queued again.
66const PENDING_TIMEOUT: Duration = Duration::from_secs(30);
67
68impl CachedHostname {
69    /// Whether this entry still answers for its address: resolved names live
70    /// for `cache_ttl`, failures for `negative_cache_ttl`, and in-flight
71    /// lookups for [`PENDING_TIMEOUT`].
72    fn is_fresh(&self, cache_ttl: Duration, negative_cache_ttl: Duration) -> bool {
73        let age = self.resolved_at.elapsed();
74        match self.state {
75            ResolutionState::Resolved => age < cache_ttl,
76            ResolutionState::Failed => age < negative_cache_ttl,
77            ResolutionState::Pending => age < PENDING_TIMEOUT,
78        }
79    }
80
81    fn pending() -> Self {
82        Self {
83            hostname: None,
84            resolved_at: Instant::now(),
85            state: ResolutionState::Pending,
86        }
87    }
88
89    fn resolved(hostname: String) -> Self {
90        Self {
91            hostname: Some(hostname),
92            resolved_at: Instant::now(),
93            state: ResolutionState::Resolved,
94        }
95    }
96
97    fn failed() -> Self {
98        Self {
99            hostname: None,
100            resolved_at: Instant::now(),
101            state: ResolutionState::Failed,
102        }
103    }
104}
105
106/// Configuration for DNS resolver
107#[derive(Debug, Clone)]
108pub(crate) struct DnsResolverConfig {
109    /// Cache TTL for resolved hostnames (default: 5 minutes)
110    pub cache_ttl: Duration,
111    /// Cache TTL for failed lookups (default: 1 minute)
112    pub negative_cache_ttl: Duration,
113    /// Maximum cache size (default: 10000 entries)
114    pub max_cache_size: usize,
115    /// Maximum queued lookup requests (default: 10000 entries)
116    pub request_queue_capacity: usize,
117    /// Number of resolver threads (default: 4)
118    pub resolver_threads: usize,
119    /// Total time allowed for all DNS workers to stop (default: 1 second)
120    pub shutdown_timeout: Duration,
121}
122
123impl Default for DnsResolverConfig {
124    fn default() -> Self {
125        Self {
126            cache_ttl: Duration::from_secs(300),         // 5 minutes
127            negative_cache_ttl: Duration::from_secs(60), // 1 minute
128            max_cache_size: 10000,
129            request_queue_capacity: 10000,
130            resolver_threads: 4,
131            shutdown_timeout: Duration::from_secs(1),
132        }
133    }
134}
135
136#[derive(Default)]
137struct DnsResolverLifecycle {
138    started: bool,
139    stopped: bool,
140    handles: Vec<JoinHandle<()>>,
141    stop_report: Option<DnsStopReport>,
142}
143
144/// Outcome of stopping the DNS resolver's background workers.
145///
146/// A worker is counted exactly once. Successfully joined workers contribute to
147/// `joined`, workers whose join observed a panic contribute to `panicked`, and
148/// workers still running when the shared shutdown deadline expires contribute
149/// to `timed_out`. Timed-out worker handles are detached because a blocking
150/// system resolver call cannot be forcibly cancelled safely.
151#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
152pub struct DnsStopReport {
153    /// Workers that exited and were joined successfully.
154    pub joined: usize,
155    /// Workers that exited with a panic.
156    pub panicked: usize,
157    /// Workers detached after the shutdown deadline expired.
158    pub timed_out: usize,
159}
160
161/// Background DNS resolver with caching
162pub struct DnsResolver {
163    /// Hostname cache: IP -> CachedHostname
164    cache: Arc<DashMap<IpAddr, CachedHostname>>,
165    /// Channel to send IPs for resolution
166    request_tx: Sender<ResolutionRequest>,
167    /// Channel consumed by resolver threads once background work is started
168    request_rx: Receiver<ResolutionRequest>,
169    /// Startup, shutdown, and worker ownership
170    lifecycle: Mutex<DnsResolverLifecycle>,
171    /// Control flag for shutdown
172    should_stop: Arc<AtomicBool>,
173    /// Configuration
174    config: DnsResolverConfig,
175}
176
177impl DnsResolver {
178    /// Build a DNS resolver without starting background threads.
179    fn new_deferred(config: DnsResolverConfig) -> Self {
180        let cache = Arc::new(DashMap::new());
181        let (request_tx, request_rx) = channel::bounded(config.request_queue_capacity);
182        let should_stop = Arc::new(AtomicBool::new(false));
183
184        Self {
185            cache,
186            request_tx,
187            request_rx,
188            lifecycle: Mutex::new(DnsResolverLifecycle::default()),
189            should_stop,
190            config,
191        }
192    }
193
194    /// Create a DNS resolver that will not spawn background threads until
195    /// [`DnsResolver::start`] is called.
196    ///
197    /// This is intended for runtimes that must finish privileged setup and
198    /// apply a process sandbox before starting general worker threads.
199    pub fn with_defaults_deferred() -> Self {
200        Self::new_deferred(DnsResolverConfig::default())
201    }
202
203    /// Start the background resolver and cache-cleanup threads.
204    ///
205    /// Starting is idempotent. A resolver that has already been stopped cannot
206    /// be restarted.
207    ///
208    /// Returns an error if a worker cannot be spawned. Workers staged before
209    /// that failure are stopped and joined before the error is returned.
210    pub fn start(&self) -> anyhow::Result<()> {
211        self.start_with_spawner(|name, worker| thread::Builder::new().name(name).spawn(worker))
212    }
213
214    fn start_with_spawner(
215        &self,
216        mut spawn: impl FnMut(String, Worker) -> std::io::Result<JoinHandle<()>>,
217    ) -> anyhow::Result<()> {
218        let mut lifecycle = self
219            .lifecycle
220            .lock()
221            .unwrap_or_else(|error| error.into_inner());
222        if lifecycle.started || lifecycle.stopped || self.should_stop.load(Ordering::Acquire) {
223            return Ok(());
224        }
225
226        // Staged workers wait here until every spawn succeeds. If a later spawn
227        // fails, the workers are released directly into their exit path and can
228        // all be joined without starting a potentially blocking resolver call.
229        let startup_gate = Arc::new((Mutex::new(None), Condvar::new()));
230        let mut handles = Vec::with_capacity(self.config.resolver_threads + 1);
231
232        for index in 0..self.config.resolver_threads {
233            let rx = self.request_rx.clone();
234            let cache = Arc::clone(&self.cache);
235            let should_stop = Arc::clone(&self.should_stop);
236            let worker_gate = Arc::clone(&startup_gate);
237
238            let worker: Worker = Box::new(move || {
239                if !wait_for_startup(&worker_gate) {
240                    return;
241                }
242
243                debug!("DNS resolver thread {} started", index);
244
245                while !should_stop.load(Ordering::Relaxed) {
246                    match rx.recv_timeout(Duration::from_millis(100)) {
247                        Ok(request) => {
248                            let reservation_is_current =
249                                cache.get(&request.ip).is_some_and(|entry| {
250                                    entry.state == ResolutionState::Pending
251                                        && entry.resolved_at == request.reserved_at
252                                });
253                            if !reservation_is_current {
254                                continue;
255                            }
256
257                            let result = match lookup_addr(&request.ip) {
258                                Ok(hostname) => {
259                                    debug!("Resolved {} -> {}", request.ip, hostname);
260                                    CachedHostname::resolved(hostname)
261                                }
262                                Err(error) => {
263                                    debug!("Failed to resolve {}: {}", request.ip, error);
264                                    CachedHostname::failed()
265                                }
266                            };
267
268                            // A timed-out reservation may have been superseded
269                            // while the system resolver was blocked. Never let
270                            // its late result overwrite the newer generation.
271                            if let Entry::Occupied(mut entry) = cache.entry(request.ip)
272                                && entry.get().state == ResolutionState::Pending
273                                && entry.get().resolved_at == request.reserved_at
274                            {
275                                entry.insert(result);
276                            }
277                        }
278                        Err(crossbeam::channel::RecvTimeoutError::Timeout) => continue,
279                        Err(crossbeam::channel::RecvTimeoutError::Disconnected) => break,
280                    }
281                }
282
283                debug!("DNS resolver thread {} stopping", index);
284            });
285
286            match spawn(format!("dns-resolver-{index}"), worker) {
287                Ok(handle) => handles.push(handle),
288                Err(error) => {
289                    return Err(Self::rollback_failed_start(&startup_gate, handles, error));
290                }
291            }
292        }
293
294        let cache = Arc::clone(&self.cache);
295        let should_stop = Arc::clone(&self.should_stop);
296        let cache_ttl = self.config.cache_ttl;
297        let negative_cache_ttl = self.config.negative_cache_ttl;
298        let max_cache_size = self.config.max_cache_size;
299        let worker_gate = Arc::clone(&startup_gate);
300        let cleanup: Worker = Box::new(move || {
301            if !wait_for_startup(&worker_gate) {
302                return;
303            }
304
305            debug!("DNS cache cleanup thread started");
306
307            while !should_stop.load(Ordering::Relaxed) {
308                // `stop` unparks this thread so shutdown does not wait for
309                // the normal cleanup interval to elapse.
310                thread::park_timeout(Duration::from_secs(30));
311
312                if should_stop.load(Ordering::Relaxed) {
313                    break;
314                }
315
316                // Remove expired entries (including timed-out pending lookups)
317                cache.retain(|_, entry| entry.is_fresh(cache_ttl, negative_cache_ttl));
318
319                // If cache is too large, remove oldest entries
320                if cache.len() > max_cache_size {
321                    let mut entries: Vec<_> =
322                        cache.iter().map(|e| (*e.key(), e.resolved_at)).collect();
323                    entries.sort_by_key(|(_, time)| *time);
324
325                    let to_remove = cache.len() - max_cache_size;
326                    for (ip, _) in entries.into_iter().take(to_remove) {
327                        cache.remove(&ip);
328                    }
329                }
330
331                debug!("DNS cache size: {}", cache.len());
332            }
333
334            debug!("DNS cache cleanup thread stopping");
335        });
336
337        match spawn("dns-cache-cleanup".to_string(), cleanup) {
338            Ok(handle) => handles.push(handle),
339            Err(error) => {
340                return Err(Self::rollback_failed_start(&startup_gate, handles, error));
341            }
342        }
343
344        lifecycle.started = true;
345        lifecycle.handles = handles;
346        release_startup_gate(&startup_gate, true);
347        Ok(())
348    }
349
350    fn rollback_failed_start(
351        startup_gate: &StartupGate,
352        handles: Vec<JoinHandle<()>>,
353        error: std::io::Error,
354    ) -> anyhow::Error {
355        release_startup_gate(startup_gate, false);
356        let panicked = handles
357            .into_iter()
358            .map(|handle| handle.join().is_err())
359            .filter(|panicked| *panicked)
360            .count();
361        if panicked == 0 {
362            anyhow::anyhow!("failed to spawn DNS worker: {error}")
363        } else {
364            anyhow::anyhow!(
365                "failed to spawn DNS worker: {error}; {panicked} staged worker(s) panicked during rollback"
366            )
367        }
368    }
369
370    /// Request resolution for an IP address (non-blocking)
371    pub fn request_resolution(&self, ip: IpAddr) {
372        if self.should_stop.load(Ordering::Acquire)
373            || matches!(classify(ip), Scope::Loopback | Scope::LinkLocal)
374        {
375            return;
376        }
377
378        let pending = CachedHostname::pending();
379        let request = ResolutionRequest {
380            ip,
381            reserved_at: pending.resolved_at,
382        };
383        match self.cache.entry(ip) {
384            Entry::Occupied(mut entry) => {
385                if entry
386                    .get()
387                    .is_fresh(self.config.cache_ttl, self.config.negative_cache_ttl)
388                {
389                    return;
390                }
391                entry.insert(pending);
392            }
393            Entry::Vacant(entry) => {
394                entry.insert(pending);
395            }
396        }
397
398        // Never let reverse DNS backpressure packet processing. A full queue
399        // drops this attempt. Remove only this attempt's reservation so a later
400        // display or export pass can retry without disturbing a newer request.
401        if self.request_tx.try_send(request).is_err() {
402            self.cache.remove_if(&ip, |_, entry| {
403                entry.state == ResolutionState::Pending && entry.resolved_at == request.reserved_at
404            });
405        }
406    }
407
408    /// Get hostname for IP if resolved, otherwise return None
409    pub fn get_hostname(&self, ip: &IpAddr) -> Option<String> {
410        self.request_resolution(*ip);
411
412        self.cache.get(ip).and_then(|entry| {
413            if entry.state == ResolutionState::Resolved {
414                entry.hostname.clone()
415            } else {
416                None
417            }
418        })
419    }
420
421    /// Stop the resolver and join background workers within a shared deadline.
422    ///
423    /// Stopping is idempotent and prevents a deferred resolver from starting.
424    /// All workers share one deadline, so several blocked resolver calls cannot
425    /// extend shutdown one timeout at a time. Workers that remain blocked after
426    /// the deadline are detached and reported as timed out.
427    pub fn stop(&self) -> DnsStopReport {
428        self.should_stop.store(true, Ordering::Release);
429
430        let mut lifecycle = self.lifecycle.lock().unwrap_or_else(|e| e.into_inner());
431        if let Some(report) = lifecycle.stop_report {
432            return report;
433        }
434
435        lifecycle.stopped = true;
436
437        for handle in &lifecycle.handles {
438            handle.thread().unpark();
439        }
440
441        let deadline = Instant::now() + self.config.shutdown_timeout;
442        let mut report = DnsStopReport::default();
443
444        while !lifecycle.handles.is_empty() {
445            let mut index = 0;
446            while index < lifecycle.handles.len() {
447                if lifecycle.handles[index].is_finished() {
448                    let handle = lifecycle.handles.swap_remove(index);
449                    if handle.join().is_err() {
450                        report.panicked += 1;
451                        debug!("DNS worker thread panicked during shutdown");
452                    } else {
453                        report.joined += 1;
454                    }
455                } else {
456                    index += 1;
457                }
458            }
459
460            if lifecycle.handles.is_empty() {
461                break;
462            }
463
464            let now = Instant::now();
465            if now >= deadline {
466                report.timed_out = lifecycle.handles.len();
467                lifecycle.handles.clear();
468                break;
469            }
470
471            thread::sleep((deadline - now).min(Duration::from_millis(1)));
472        }
473
474        lifecycle.stop_report = Some(report);
475        report
476    }
477}
478
479impl Drop for DnsResolver {
480    fn drop(&mut self) {
481        let _ = self.stop();
482    }
483}
484
485#[cfg(test)]
486mod tests {
487    use super::*;
488
489    #[test]
490    fn test_cached_hostname_states() {
491        let pending = CachedHostname::pending();
492        assert_eq!(pending.state, ResolutionState::Pending);
493        assert!(pending.hostname.is_none());
494
495        let resolved = CachedHostname::resolved("example.com".to_string());
496        assert_eq!(resolved.state, ResolutionState::Resolved);
497        assert_eq!(resolved.hostname, Some("example.com".to_string()));
498
499        let failed = CachedHostname::failed();
500        assert_eq!(failed.state, ResolutionState::Failed);
501        assert!(failed.hostname.is_none());
502    }
503
504    #[test]
505    fn test_loopback_skip() {
506        let config = DnsResolverConfig {
507            resolver_threads: 1,
508            ..Default::default()
509        };
510        let resolver = DnsResolver::new_deferred(config);
511        resolver.start().unwrap();
512
513        // Loopback should not be queued
514        resolver.request_resolution("127.0.0.1".parse().unwrap());
515        assert!(
516            resolver
517                .get_hostname(&"127.0.0.1".parse().unwrap())
518                .is_none()
519        );
520
521        let report = resolver.stop();
522        assert_eq!(report.timed_out, 0);
523    }
524
525    #[test]
526    fn deferred_resolver_stays_inactive_until_started() {
527        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
528            resolver_threads: 0,
529            ..Default::default()
530        });
531
532        {
533            let lifecycle = resolver.lifecycle.lock().unwrap();
534            assert!(!lifecycle.started);
535            assert!(!lifecycle.stopped);
536            assert!(lifecycle.handles.is_empty());
537        }
538
539        resolver.start().unwrap();
540        {
541            let lifecycle = resolver.lifecycle.lock().unwrap();
542            assert!(lifecycle.started);
543            assert!(!lifecycle.stopped);
544            assert_eq!(lifecycle.handles.len(), 1);
545        }
546
547        // Starting twice is a no-op.
548        resolver.start().unwrap();
549        assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 1);
550
551        resolver.stop();
552    }
553
554    #[test]
555    fn stopped_deferred_resolver_cannot_be_started() {
556        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
557            resolver_threads: 0,
558            ..Default::default()
559        });
560
561        let report = resolver.stop();
562        assert_eq!(report, DnsStopReport::default());
563        resolver.start().unwrap();
564
565        let lifecycle = resolver.lifecycle.lock().unwrap();
566        assert!(!lifecycle.started);
567        assert!(lifecycle.stopped);
568        assert!(lifecycle.handles.is_empty());
569    }
570
571    #[test]
572    fn request_queue_is_bounded_and_non_blocking() {
573        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
574            request_queue_capacity: 1,
575            resolver_threads: 0,
576            ..Default::default()
577        });
578        let first = "192.0.2.1".parse().unwrap();
579        let second = "192.0.2.2".parse().unwrap();
580
581        resolver.request_resolution(first);
582        resolver.request_resolution(second);
583
584        assert_eq!(resolver.request_rx.len(), 1);
585        assert_eq!(resolver.request_rx.try_recv().unwrap().ip, first);
586        assert!(resolver.request_rx.try_recv().is_err());
587    }
588
589    #[test]
590    fn repeated_requests_share_one_queue_reservation() {
591        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
592            request_queue_capacity: 4,
593            resolver_threads: 0,
594            ..Default::default()
595        });
596        let address = "192.0.2.1".parse().unwrap();
597
598        for _ in 0..32 {
599            resolver.request_resolution(address);
600        }
601
602        assert_eq!(resolver.request_rx.len(), 1);
603        assert_eq!(resolver.request_rx.try_recv().unwrap().ip, address);
604        assert!(resolver.request_rx.try_recv().is_err());
605    }
606
607    #[test]
608    fn concurrent_requests_share_one_queue_reservation() {
609        let resolver = Arc::new(DnsResolver::new_deferred(DnsResolverConfig {
610            request_queue_capacity: 32,
611            resolver_threads: 0,
612            ..Default::default()
613        }));
614        let address = "192.0.2.1".parse().unwrap();
615        let ready = Arc::new(std::sync::Barrier::new(17));
616        let mut callers = Vec::new();
617        for _ in 0..16 {
618            let resolver = Arc::clone(&resolver);
619            let ready = Arc::clone(&ready);
620            callers.push(thread::spawn(move || {
621                ready.wait();
622                resolver.request_resolution(address);
623            }));
624        }
625
626        ready.wait();
627        for caller in callers {
628            caller.join().unwrap();
629        }
630
631        assert_eq!(resolver.request_rx.len(), 1);
632        assert_eq!(resolver.request_rx.try_recv().unwrap().ip, address);
633    }
634
635    #[test]
636    fn full_queue_releases_reservation_for_retry() {
637        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
638            request_queue_capacity: 1,
639            resolver_threads: 0,
640            ..Default::default()
641        });
642        let first = "192.0.2.1".parse().unwrap();
643        let retry = "192.0.2.2".parse().unwrap();
644
645        resolver.request_resolution(first);
646        resolver.request_resolution(retry);
647        assert!(!resolver.cache.contains_key(&retry));
648
649        assert_eq!(resolver.request_rx.try_recv().unwrap().ip, first);
650        resolver.request_resolution(retry);
651        assert_eq!(resolver.request_rx.try_recv().unwrap().ip, retry);
652    }
653
654    #[test]
655    fn failed_start_joins_staged_workers_and_can_be_retried() {
656        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
657            resolver_threads: 2,
658            ..Default::default()
659        });
660        let staged_worker_exited = Arc::new(AtomicBool::new(false));
661        let exited = Arc::clone(&staged_worker_exited);
662        let mut attempts = 0;
663
664        let error = resolver
665            .start_with_spawner(move |name, worker| {
666                attempts += 1;
667                if attempts == 2 {
668                    return Err(std::io::Error::other("injected spawn failure"));
669                }
670                let exited = Arc::clone(&exited);
671                thread::Builder::new().name(name).spawn(move || {
672                    worker();
673                    exited.store(true, Ordering::Release);
674                })
675            })
676            .unwrap_err();
677
678        assert!(error.to_string().contains("injected spawn failure"));
679        assert!(staged_worker_exited.load(Ordering::Acquire));
680        {
681            let lifecycle = resolver.lifecycle.lock().unwrap();
682            assert!(!lifecycle.started);
683            assert!(!lifecycle.stopped);
684            assert!(lifecycle.handles.is_empty());
685        }
686
687        resolver.start().unwrap();
688        assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 3);
689        let report = resolver.stop();
690        assert_eq!(report.joined, 3);
691        assert_eq!(report.timed_out, 0);
692    }
693
694    #[test]
695    fn stop_joins_workers_and_is_idempotent() {
696        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
697            resolver_threads: 1,
698            ..Default::default()
699        });
700        resolver.start().unwrap();
701        assert_eq!(resolver.lifecycle.lock().unwrap().handles.len(), 2);
702
703        let before_stop = Instant::now();
704        let report = resolver.stop();
705        assert!(before_stop.elapsed() < Duration::from_secs(1));
706        assert_eq!(report.joined, 2);
707        assert_eq!(report.panicked, 0);
708        assert_eq!(report.timed_out, 0);
709
710        {
711            let lifecycle = resolver.lifecycle.lock().unwrap();
712            assert!(lifecycle.started);
713            assert!(lifecycle.stopped);
714            assert!(lifecycle.handles.is_empty());
715        }
716
717        assert_eq!(resolver.stop(), report);
718        assert!(resolver.lifecycle.lock().unwrap().handles.is_empty());
719    }
720
721    #[test]
722    fn stop_detaches_stalled_worker_at_shared_deadline() {
723        let resolver = DnsResolver::new_deferred(DnsResolverConfig {
724            resolver_threads: 0,
725            shutdown_timeout: Duration::from_millis(25),
726            ..Default::default()
727        });
728        let (release_tx, release_rx) = channel::bounded::<()>(0);
729        let stalled = thread::spawn(move || {
730            let _ = release_rx.recv();
731        });
732        resolver.lifecycle.lock().unwrap().handles.push(stalled);
733
734        let before_stop = Instant::now();
735        let report = resolver.stop();
736
737        assert!(before_stop.elapsed() < Duration::from_millis(250));
738        assert_eq!(
739            report,
740            DnsStopReport {
741                joined: 0,
742                panicked: 0,
743                timed_out: 1,
744            }
745        );
746        assert_eq!(resolver.stop(), report);
747
748        // The detached worker can still finish safely after the resolver stops.
749        let _ = release_tx.send(());
750    }
751
752    #[test]
753    fn test_default_config() {
754        let config = DnsResolverConfig::default();
755        assert_eq!(config.cache_ttl, Duration::from_secs(300));
756        assert_eq!(config.negative_cache_ttl, Duration::from_secs(60));
757        assert_eq!(config.max_cache_size, 10000);
758        assert_eq!(config.request_queue_capacity, 10000);
759        assert_eq!(config.resolver_threads, 4);
760        assert_eq!(config.shutdown_timeout, Duration::from_secs(1));
761    }
762}