rotonda 0.4.0

composable, programmable BGP engine
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

use std::{fmt::Display, time::Duration};

use serde::{self, Deserialize};
use serde_with::serde_as;

pub const DEF_MQTT_PORT: u16 = 1883;

// -------- Destination ------------------------------------------------------

#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(try_from = "String")]
pub struct Destination {
    /// MQTT server host name or IP address
    pub host: String,

    /// MQTT server TCP port number
    pub port: u16,
}

impl TryFrom<String> for Destination {
    type Error = String;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        let (host, port) = match value.split_once(':') {
            Some((host, port)) => (
                host.to_string(),
                port.parse::<u16>().map_err(|err| err.to_string())?,
            ),
            None => (value, DEF_MQTT_PORT),
        };

        if host.is_empty() {
            Err("Host part of MQTT server address must not be empty"
                .to_string())
        } else {
            Ok(Self { host, port })
        }
    }
}

impl From<(String, u16)> for Destination {
    fn from((host, port): (String, u16)) -> Self {
        Self { host, port }
    }
}

impl Display for Destination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("{}:{}", self.host, self.port))
    }
}

// -------- ClientId ---------------------------------------------------------

/// MQTT client ID
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(try_from = "String")]
pub struct ClientId(pub String);

impl std::ops::Deref for ClientId {
    type Target = String;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl TryFrom<String> for ClientId {
    type Error = &'static str;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        if value.starts_with(' ') {
            Err("MQTT client id must not contain leading whitespace")
        } else if value.is_empty() {
            Err("MQTT client id must not be empty")
        } else {
            Ok(Self(value))
        }
    }
}

impl From<ClientId> for String {
    fn from(val: ClientId) -> Self {
        val.0
    }
}

#[serde_as]
#[derive(Debug, Default, Deserialize)]
pub struct Config {
    /// MQTT server host[:port] to publish to
    pub destination: Destination,

    #[serde(default = "Config::default_qos")]
    pub qos: i32,

    pub client_id: ClientId,

    #[serde(default = "Config::default_topic_template")]
    pub topic_template: String,

    /// How long to wait in seconds before connecting again if the connection
    /// is closed.
    #[serde_as(as = "serde_with::DurationSeconds<u64>")]
    #[serde(default = "Config::default_connect_retry_secs")]
    pub connect_retry_secs: Duration,

    /// How long to wait before timing out an attempt to publish a message.
    #[serde_as(as = "serde_with::DurationSeconds<u64>")]
    #[serde(default = "Config::default_publish_max_secs")]
    pub publish_max_secs: Duration,

    /// How many messages to buffer if publishing encounters delays
    #[serde(default = "Config::default_queue_size")]
    pub queue_size: u16,

    #[serde(default)]
    pub username: Option<String>,

    #[serde(default)]
    pub password: Option<String>,
}

impl Config {
    /// The default MQTT quality of service setting to use
    ///   0 - At most once delivery
    ///   1 - At least once delivery
    ///   2 - Exactly once delivery
    pub fn default_qos() -> i32 {
        2
    }

    /// The default re-connect timeout in seconds.
    pub fn default_connect_retry_secs() -> Duration {
        Duration::from_secs(60)
    }

    /// The default publish timeout in seconds.
    pub fn default_publish_max_secs() -> Duration {
        Duration::from_secs(5)
    }

    /// The default MQTT topic prefix.
    pub fn default_topic_template() -> String {
        "rotonda/{id}".to_string()
    }

    /// The default re-connect timeout in seconds.
    pub fn default_queue_size() -> u16 {
        1000
    }
}