trippy-dns 0.13.0

A lazy DNS resolver for Trippy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{IpAddrFamily, ResolveMethod};
use std::time::Duration;

/// A builder for DNS `Config`.
///
/// # Example
///
/// Build a DNS `Config` for the `Ipv4Only` address family.
///
/// ```no_run
/// use trippy_dns::{Builder, IpAddrFamily};
///
/// let config = Builder::new().addr_family(IpAddrFamily::Ipv4Only).build();
pub struct Builder {
    resolve_method: ResolveMethod,
    addr_family: IpAddrFamily,
    timeout: Duration,
    ttl: Duration,
}

impl Builder {
    /// Create a new `Builder`.
    #[must_use]
    pub fn new() -> Self {
        Self {
            resolve_method: Config::default().resolve_method,
            addr_family: Config::default().addr_family,
            timeout: Config::default().timeout,
            ttl: Config::default().ttl,
        }
    }

    /// Set the method to use for DNS resolution.
    #[must_use]
    pub const fn resolve_method(self, resolve_method: ResolveMethod) -> Self {
        Self {
            resolve_method,
            ..self
        }
    }

    /// Set the address family.
    #[must_use]
    pub const fn addr_family(self, addr_family: IpAddrFamily) -> Self {
        Self {
            addr_family,
            ..self
        }
    }

    /// Set the timeout for DNS resolution.
    #[must_use]
    pub const fn timeout(self, timeout: Duration) -> Self {
        Self { timeout, ..self }
    }

    /// Set the time-to-live (TTL) for DNS cache entries.
    #[must_use]
    pub const fn ttl(self, ttl: Duration) -> Self {
        Self { ttl, ..self }
    }

    /// Build the DNS `Config`.
    #[must_use]
    pub const fn build(self) -> Config {
        Config {
            resolve_method: self.resolve_method,
            addr_family: self.addr_family,
            timeout: self.timeout,
            ttl: self.ttl,
        }
    }
}

impl Default for Builder {
    fn default() -> Self {
        Self::new()
    }
}

/// Configuration for the `DnsResolver`.
#[derive(Debug, Copy, Clone)]
pub struct Config {
    /// The method to use for DNS resolution.
    pub resolve_method: ResolveMethod,
    /// The IP address resolution family.
    pub addr_family: IpAddrFamily,
    /// The timeout for DNS resolution.
    pub timeout: Duration,
    /// The time-to-live (TTL) for DNS cache entries.
    pub ttl: Duration,
}

impl Config {
    /// Create a `Config`.
    #[must_use]
    pub const fn new(
        resolve_method: ResolveMethod,
        addr_family: IpAddrFamily,
        timeout: Duration,
        ttl: Duration,
    ) -> Self {
        Self {
            resolve_method,
            addr_family,
            timeout,
            ttl,
        }
    }
}

impl Default for Config {
    fn default() -> Self {
        Self {
            resolve_method: ResolveMethod::System,
            addr_family: IpAddrFamily::Ipv4thenIpv6,
            timeout: Duration::from_millis(5000),
            ttl: Duration::from_secs(300),
        }
    }
}