zeronsd 0.5.0

Unicast DNS resolver for ZeroTier networks
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

use std::str::FromStr;

use anyhow::anyhow;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum LevelFilter {
    #[serde(rename(deserialize = "off"))]
    Off,
    #[serde(rename(deserialize = "error"))]
    Error,
    #[serde(rename(deserialize = "warn"))]
    Warn,
    #[serde(rename(deserialize = "info"))]
    Info,
    #[serde(rename(deserialize = "trace"))]
    Trace,
    #[serde(rename(deserialize = "debug"))]
    Debug,
}

impl LevelFilter {
    pub fn to_log(&self) -> Option<tracing::Level> {
        match self {
            LevelFilter::Off => None,
            LevelFilter::Error => Some(tracing::Level::ERROR),
            LevelFilter::Warn => Some(tracing::Level::WARN),
            LevelFilter::Info => Some(tracing::Level::INFO),
            LevelFilter::Trace => Some(tracing::Level::TRACE),
            LevelFilter::Debug => Some(tracing::Level::DEBUG),
        }
    }
}

impl ToString for LevelFilter {
    fn to_string(&self) -> String {
        match self {
            LevelFilter::Off => "off",
            LevelFilter::Error => "error",
            LevelFilter::Warn => "warn",
            LevelFilter::Info => "info",
            LevelFilter::Trace => "trace",
            LevelFilter::Debug => "debug",
        }
        .to_string()
    }
}

impl FromStr for LevelFilter {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "off" => Ok(Self::Off),
            "error" => Ok(Self::Error),
            "warn" => Ok(Self::Warn),
            "info" => Ok(Self::Info),
            "trace" => Ok(Self::Trace),
            "debug" => Ok(Self::Debug),
            _ => Err(anyhow!(
                "invalid format: allowed values: [off, error, warn, info, debug, trace]"
            )),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::LevelFilter;
    use std::str::FromStr;

    #[test]
    fn test_level_from_str() {
        for item in vec![
            ("off", LevelFilter::Off),
            ("error", LevelFilter::Error),
            ("warn", LevelFilter::Warn),
            ("info", LevelFilter::Info),
            ("trace", LevelFilter::Trace),
            ("debug", LevelFilter::Debug),
        ] {
            assert_eq!(LevelFilter::from_str(item.0).unwrap(), item.1)
        }

        assert!(LevelFilter::from_str("foo").is_err());
    }

    #[test]
    fn test_level_to_string() {
        for item in vec![
            (LevelFilter::Off, "off"),
            (LevelFilter::Error, "error"),
            (LevelFilter::Warn, "warn"),
            (LevelFilter::Info, "info"),
            (LevelFilter::Trace, "trace"),
            (LevelFilter::Debug, "debug"),
        ] {
            assert_eq!(item.0.to_string(), item.1)
        }
    }
}