modo-rs 0.8.0

Rust web framework for small monolithic apps
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Configuration for the DNS verification module.

use std::net::SocketAddr;

use serde::Deserialize;

use crate::error::{Error, Result};

fn default_txt_prefix() -> String {
    "_modo-verify".into()
}

fn default_timeout_ms() -> u64 {
    5000
}

/// Configuration for [`super::DomainVerifier`].
///
/// Deserializes from YAML via `serde`. The `txt_prefix` and `timeout_ms`
/// fields have defaults and can be omitted.
///
/// # Example (YAML)
///
/// ```yaml
/// dns:
///   nameserver: "8.8.8.8:53"
///   txt_prefix: "_myapp-verify"   # default: _modo-verify
///   timeout_ms: 5000              # default: 5000
/// ```
#[non_exhaustive]
#[derive(Debug, Clone, Deserialize)]
#[serde(default)]
pub struct DnsConfig {
    /// Nameserver address, with or without port. Port 53 is appended when omitted.
    ///
    /// Examples: `"8.8.8.8:53"`, `"1.1.1.1"`.
    pub nameserver: String,
    /// Prefix prepended to the domain when looking up TXT records.
    ///
    /// The resolved TXT lookup name is `{txt_prefix}.{domain}`.
    /// Defaults to `"_modo-verify"`.
    #[serde(default = "default_txt_prefix")]
    pub txt_prefix: String,
    /// UDP receive timeout in milliseconds. Defaults to `5000`.
    #[serde(default = "default_timeout_ms")]
    pub timeout_ms: u64,
}

impl Default for DnsConfig {
    fn default() -> Self {
        Self {
            nameserver: "8.8.8.8".into(),
            txt_prefix: "_modo-verify".into(),
            timeout_ms: 5000,
        }
    }
}

impl DnsConfig {
    /// Create a DNS configuration with the given nameserver address.
    ///
    /// Defaults: `txt_prefix = "_modo-verify"`, `timeout_ms = 5000`.
    pub fn new(nameserver: impl Into<String>) -> Self {
        Self {
            nameserver: nameserver.into(),
            txt_prefix: "_modo-verify".into(),
            timeout_ms: 5000,
        }
    }

    /// Parse `nameserver` into a [`SocketAddr`].
    ///
    /// If the address already contains a port it is used as-is; otherwise port
    /// `53` is appended.
    ///
    /// # Errors
    ///
    /// Returns [`crate::Error`] with status 500 when the address is not a
    /// valid IP or hostname+port.
    pub fn parse_nameserver(&self) -> Result<SocketAddr> {
        if let Ok(addr) = self.nameserver.parse::<SocketAddr>() {
            return Ok(addr);
        }
        let with_port = format!("{}:53", self.nameserver);
        with_port.parse::<SocketAddr>().map_err(|_| {
            Error::internal(format!(
                "invalid dns nameserver address: {}",
                self.nameserver
            ))
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_full_config() {
        let yaml = r#"
nameserver: "8.8.8.8:53"
txt_prefix: "_myapp-verify"
timeout_ms: 3000
"#;
        let config: DnsConfig = serde_yaml_ng::from_str(yaml).unwrap();
        assert_eq!(config.nameserver, "8.8.8.8:53");
        assert_eq!(config.txt_prefix, "_myapp-verify");
        assert_eq!(config.timeout_ms, 3000);
    }

    #[test]
    fn defaults_applied_when_fields_omitted() {
        let yaml = r#"
nameserver: "8.8.8.8"
"#;
        let config: DnsConfig = serde_yaml_ng::from_str(yaml).unwrap();
        assert_eq!(config.nameserver, "8.8.8.8");
        assert_eq!(config.txt_prefix, "_modo-verify");
        assert_eq!(config.timeout_ms, 5000);
    }

    #[test]
    fn parse_nameserver_with_port() {
        let config = DnsConfig {
            nameserver: "1.1.1.1:53".into(),
            txt_prefix: "_modo-verify".into(),
            timeout_ms: 5000,
        };
        let addr = config.parse_nameserver().unwrap();
        assert_eq!(addr.to_string(), "1.1.1.1:53");
    }

    #[test]
    fn parse_nameserver_without_port_appends_53() {
        let config = DnsConfig {
            nameserver: "8.8.8.8".into(),
            txt_prefix: "_modo-verify".into(),
            timeout_ms: 5000,
        };
        let addr = config.parse_nameserver().unwrap();
        assert_eq!(addr.to_string(), "8.8.8.8:53");
    }

    #[test]
    fn parse_nameserver_invalid_address_fails() {
        let config = DnsConfig {
            nameserver: "not-an-address".into(),
            txt_prefix: "_modo-verify".into(),
            timeout_ms: 5000,
        };
        let err = config.parse_nameserver().unwrap_err();
        assert_eq!(err.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
    }
}