pass-it-on 0.16.6

A library that provides a simple notification client and server that receives messages and passes them on to endpoints
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

#[cfg(all(feature = "parse-cfg", feature = "client"))]
pub mod client_configuration_file;
#[cfg(all(feature = "parse-cfg", feature = "server"))]
pub mod server_configuration_file;

#[cfg(feature = "server")]
use crate::endpoints::{Endpoint, EndpointChannel, EndpointConfig};
use crate::interfaces::{Interface, InterfaceConfig};
use crate::notifications::Key;
use crate::Error;

#[cfg(feature = "server")]
/// Server configuration that can be used to start the server.
#[derive(Debug)]
pub struct ServerConfiguration {
    key: Key,
    interfaces: Vec<Box<dyn Interface + Send>>,
    endpoints: Vec<Box<dyn Endpoint + Send>>,
}

#[cfg(feature = "server")]
impl ServerConfiguration {
    /// Create a new `ServerConfiguration`.
    pub fn new<S: AsRef<str>>(
        key: S,
        interfaces: Vec<Box<dyn Interface + Send>>,
        endpoints: Vec<Box<dyn Endpoint + Send>>,
    ) -> Result<Self, Error> {
        let key = Key::derive_shared_key(key);
        let config = Self { key, interfaces, endpoints };
        Self::validate(config)
    }

    pub(crate) fn endpoint_channels(&self) -> Vec<EndpointChannel> {
        use crate::notifications::ValidatedNotification;
        use crate::CHANNEL_BUFFER;
        use tokio::sync::broadcast;
        use tokio::sync::broadcast::{Receiver, Sender};

        let mut endpoints = Vec::new();
        for endpoint in &self.endpoints {
            let (endpoint_tx, _endpoint_rx): (Sender<ValidatedNotification>, Receiver<ValidatedNotification>) =
                broadcast::channel(CHANNEL_BUFFER);
            let keys = endpoint.generate_keys(&self.key);
            endpoints.push(EndpointChannel::from(endpoint.clone(), endpoint_tx, keys));
        }
        endpoints
    }

    /// Return server [`Key`] value.
    pub fn key(&self) -> &Key {
        &self.key
    }

    /// Return all server interfaces.
    pub fn interfaces(&self) -> Vec<Box<dyn Interface + Send>> {
        self.interfaces.clone()
    }

    /// Return all server endpoints.
    pub fn endpoints(&self) -> &[Box<dyn Endpoint + Send>] {
        &self.endpoints
    }

    fn validate(config: ServerConfiguration) -> Result<ServerConfiguration, Error> {
        if config.interfaces.is_empty() {
            return Err(Error::MissingInterface);
        }

        if config.endpoints.is_empty() {
            return Err(Error::MissingEndpoint);
        }

        Ok(config)
    }
}

#[cfg(all(feature = "parse-cfg", feature = "server"))]
impl TryFrom<&str> for ServerConfiguration {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        server_configuration_file::ServerConfigFileParser::from(value)
    }
}

#[cfg(feature = "client")]
/// Client configuration that can be used to start the client.
#[derive(Debug)]
pub struct ClientConfiguration {
    key: Key,
    interfaces: Vec<Box<dyn Interface + Send>>,
}

#[cfg(feature = "client")]
impl ClientConfiguration {
    /// Create a new `ClientConfiguration`.
    pub fn new<S: AsRef<str>>(key: S, interfaces: Vec<Box<dyn Interface + Send>>) -> Result<Self, Error> {
        let key = Key::derive_shared_key(key);
        let config = Self { key, interfaces };
        Self::validate(config)
    }

    /// Return client [`Key`] value.
    pub fn key(&self) -> &Key {
        &self.key
    }

    /// Return all client interfaces.
    pub fn interfaces(&self) -> Vec<Box<dyn Interface + Send>> {
        self.interfaces.clone()
    }

    fn validate(config: ClientConfiguration) -> Result<ClientConfiguration, Error> {
        if config.interfaces.is_empty() {
            return Err(Error::MissingInterface);
        }
        Ok(config)
    }
}

#[cfg(all(feature = "parse-cfg", feature = "client"))]
impl TryFrom<&str> for ClientConfiguration {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        client_configuration_file::ClientConfigFileParser::from(value)
    }
}

#[cfg(all(feature = "parse-cfg", any(feature = "client", feature = "server")))]
fn collect_interfaces(
    interface_configs: Vec<Box<dyn InterfaceConfig>>,
) -> Result<Vec<Box<dyn Interface + Send>>, Error> {
    interface_configs.iter().map(|cfg| cfg.to_interface()).collect()
}

#[cfg(all(feature = "parse-cfg", feature = "server"))]
fn collect_endpoints(endpoint_configs: Vec<Box<dyn EndpointConfig>>) -> Result<Vec<Box<dyn Endpoint + Send>>, Error> {
    endpoint_configs.iter().map(|cfg| cfg.to_endpoint()).collect()
}