openvpn-mgmt-codec 0.8.0

OpenVPN management protocol codecs (tokio-util en/decoder implementations).
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

use std::fmt;
use std::str::FromStr;

/// Error returned when a string is not a recognized stream mode.
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("unrecognized stream mode: {0:?}")]
pub struct ParseStreamModeError(pub String);

/// Mode selector for commands that share the on/off/all/on-all/N grammar.
/// This is used by `log`, `state`, and `echo`, all of which support
/// identical sub-commands.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StreamMode {
    /// Enable real-time notifications.
    On,

    /// Disable real-time notifications.
    Off,

    /// Dump the entire history buffer.
    All,

    /// Atomically enable real-time notifications AND dump history.
    /// This guarantees no messages are missed between the dump and
    /// the start of real-time streaming.
    OnAll,

    /// Show the N most recent history entries.
    Recent(u32),
}

impl StreamMode {
    /// Whether this mode produces a multi-line history dump rather than a
    /// simple `SUCCESS:` acknowledgement.
    pub fn returns_history(self) -> bool {
        matches!(self, Self::All | Self::OnAll | Self::Recent(_))
    }
}

impl fmt::Display for StreamMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::On => f.write_str("on"),
            Self::Off => f.write_str("off"),
            Self::All => f.write_str("all"),
            Self::OnAll => f.write_str("on all"),
            Self::Recent(n) => write!(f, "{n}"),
        }
    }
}

impl FromStr for StreamMode {
    type Err = ParseStreamModeError;

    /// Parse a stream mode string: `on`, `off`, `all`, `on all`, or a number.
    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match input {
            "on" => Ok(Self::On),
            "off" => Ok(Self::Off),
            "all" => Ok(Self::All),
            "on all" => Ok(Self::OnAll),
            other => other
                .parse::<u32>()
                .map(Self::Recent)
                .map_err(|_| ParseStreamModeError(input.to_string())),
        }
    }
}

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

    #[test_case(StreamMode::On)]
    #[test_case(StreamMode::Off)]
    #[test_case(StreamMode::All)]
    #[test_case(StreamMode::OnAll)]
    #[test_case(StreamMode::Recent(42))]
    fn parse_roundtrip(mode: StreamMode) {
        let string = mode.to_string();
        assert_eq!(string.parse::<StreamMode>().unwrap(), mode);
    }

    #[test]
    fn parse_invalid() {
        assert!("bogus".parse::<StreamMode>().is_err());
    }
}