product-os-command-control 0.0.6

Product OS : Command and Control provides a set of tools for running command and control across a distributed set of Product OS : Servers.
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



use headers::{ Header, HeaderName };

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


#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandControlAuthenticateError {
    pub error: CommandControlAuthenticateErrorState
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CommandControlAuthenticateErrorState {
    KeyError(String),
    None
}

impl std::error::Error for CommandControlAuthenticateError {}

impl std::fmt::Display for CommandControlAuthenticateError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match &self.error {
            CommandControlAuthenticateErrorState::KeyError(m) => write!(f, "{}", m),
            CommandControlAuthenticateErrorState::None => write!(f, "No error")
        }
    }
}

lazy_static! {
    static ref X_INTERACT_COMMAND: HeaderName = HeaderName::from_static("x-product-os-command");
    static ref X_INTERACT_CONTROL: HeaderName = HeaderName::from_static("x-product-os-control");
    static ref X_INTERACT_VERIFY: HeaderName = HeaderName::from_static("x-product-os-verify");
}

pub struct XProductOSCommandHeader(String);

impl XProductOSCommandHeader {
    pub fn value(self) -> String {
        self.0
    }
}

impl Header for XProductOSCommandHeader {
    fn name() -> &'static HeaderName {
        &X_INTERACT_COMMAND
    }

    fn decode<'i, I>(values: &mut I) -> Result<Self, headers::Error>
        where
            I: Iterator<Item = &'i headers::HeaderValue> {
        let value = values
            .next()
            .ok_or_else(headers::Error::invalid)?;

        Ok(XProductOSCommandHeader(value.to_str().unwrap().to_string()))
        // Err(headers::Error::invalid())
    }

    fn encode<E>(&self, values: &mut E)
        where
            E: Extend<headers::HeaderValue> {
        let value = headers::HeaderValue::from_str(self.0.as_str()).unwrap();
        values.extend(std::iter::once(value));
    }
}

pub struct XProductOSControlHeader(String);

impl XProductOSControlHeader {
    pub fn value(self) -> String {
        self.0
    }
}

impl Header for XProductOSControlHeader {
    fn name() -> &'static HeaderName {
        &X_INTERACT_CONTROL
    }

    fn decode<'i, I>(values: &mut I) -> Result<Self, headers::Error>
        where
            I: Iterator<Item = &'i headers::HeaderValue> {
        let value = values
            .next()
            .ok_or_else(headers::Error::invalid)?;

        Ok(XProductOSControlHeader(value.to_str().unwrap().to_string()))
        // Err(headers::Error::invalid())
    }

    fn encode<E>(&self, values: &mut E)
        where
            E: Extend<headers::HeaderValue> {
        let value = headers::HeaderValue::from_str(self.0.as_str()).unwrap();
        values.extend(std::iter::once(value));
    }
}

pub struct XProductOSVerifyHeader(String);

impl XProductOSVerifyHeader {
    pub fn value(self) -> String {
        self.0
    }
}

impl Header for XProductOSVerifyHeader {
    fn name() -> &'static HeaderName {
        &X_INTERACT_VERIFY
    }

    fn decode<'i, I>(values: &mut I) -> Result<Self, headers::Error>
        where
            I: Iterator<Item = &'i headers::HeaderValue> {
        let value = values
            .next()
            .ok_or_else(headers::Error::invalid)?;

        Ok(XProductOSVerifyHeader(value.to_str().unwrap().to_string()))
        // Err(headers::Error::invalid())
    }

    fn encode<E>(&self, values: &mut E)
        where
            E: Extend<headers::HeaderValue> {
        let value = headers::HeaderValue::from_str(self.0.as_str()).unwrap();
        values.extend(std::iter::once(value));
    }
}