mikrotik 0.0.8

REST API Wrapper for Mikrotik API
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

use crate::serde_helpers::{
    deserialize_bool, deserialize_u16, deserialize_u64, maybe_deserialize_u16,
};
use serde::{
    de::{Error, Unexpected},
    Deserialize, Deserializer, Serialize,
};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum InterfaceType {
    #[serde(rename = "vlan")]
    VLAN,
    #[serde(rename = "ether")]
    Ethernet,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "wg")]
    Wireguard,
    #[serde(rename = "pppoe-out")]
    PPPoE,
}

impl Default for InterfaceType {
    fn default() -> Self {
        Self::Ethernet
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum Mtu {
    #[serde(rename = "auto")]
    Auto,
    Value(u16),
}

impl Default for Mtu {
    fn default() -> Self {
        Self::Auto
    }
}

pub fn maybe_deserialize_mtu<'de, D>(deserializer: D) -> Result<Option<Mtu>, D::Error>
where
    D: Deserializer<'de>,
{
    let s: &str = Deserialize::deserialize(deserializer)?;

    if s == "auto" {
        return Ok(Some(Mtu::Auto));
    }

    match s.parse::<u16>() {
        Ok(v) => Ok(Some(Mtu::Value(v))),
        Err(_) => Err(Error::invalid_value(Unexpected::Str(s), &"an integer")),
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Interface {
    #[serde(rename = ".id")]
    pub id: String,
    #[serde(default, rename = "actual-mtu", deserialize_with = "deserialize_u16")]
    pub actual_mtu: u16,
    pub comment: Option<String>,
    #[serde(rename = "default-name")]
    pub default_name: Option<String>,
    #[serde(deserialize_with = "deserialize_bool")]
    pub disabled: bool,
    #[serde(default, rename = "fp-rx-byte", deserialize_with = "deserialize_u64")]
    pub fp_rx_byte: u64,
    #[serde(default, rename = "fp-rx-packet", deserialize_with = "deserialize_u64")]
    pub fp_rx_packet: u64,
    #[serde(default, rename = "fp-tx-byte", deserialize_with = "deserialize_u64")]
    pub fp_tx_byte: u64,
    #[serde(default, rename = "fp-tx-packet", deserialize_with = "deserialize_u64")]
    pub fp_tx_packet: u64,
    #[serde(default, deserialize_with = "deserialize_u16")]
    pub l2mtu: u16,
    #[serde(rename = "last-link-up-time")]
    pub last_link_up_time: Option<String>,
    #[serde(default, rename = "link-downs", deserialize_with = "deserialize_u16")]
    pub link_downs: u16,
    #[serde(rename = "mac-address")]
    pub mac_address: Option<String>,
    #[serde(
        default,
        rename = "max-l2mtu",
        deserialize_with = "maybe_deserialize_u16"
    )]
    pub max_l2mtu: Option<u16>,
    #[serde(default, deserialize_with = "maybe_deserialize_mtu")]
    pub mtu: Option<Mtu>,
    pub name: String,
    #[serde(deserialize_with = "deserialize_bool")]
    pub running: bool,
    #[serde(rename = "rx-byte", deserialize_with = "deserialize_u64")]
    pub rx_byte: u64,
    #[serde(rename = "rx-drop", deserialize_with = "deserialize_u64")]
    pub rx_drop: u64,
    #[serde(rename = "rx-error", deserialize_with = "deserialize_u64")]
    pub rx_error: u64,
    #[serde(rename = "rx-packet", deserialize_with = "deserialize_u64")]
    pub rx_packet: u64,
    pub slave: Option<String>,
    #[serde(rename = "tx-byte", deserialize_with = "deserialize_u64")]
    pub tx_byte: u64,
    #[serde(rename = "tx-drop", deserialize_with = "deserialize_u64")]
    pub tx_drop: u64,
    #[serde(rename = "tx-error", deserialize_with = "deserialize_u64")]
    pub tx_error: u64,
    #[serde(rename = "tx-packet", deserialize_with = "deserialize_u64")]
    pub tx_packet: u64,
    #[serde(rename = "tx-queue-drop", deserialize_with = "deserialize_u64")]
    pub tx_queue_drop: u64,
    #[serde(rename = "type")]
    pub type_field: InterfaceType,
    #[serde(rename = "last-link-down-time")]
    pub last_link_down_time: Option<String>,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WireguardInterface {
    #[serde(rename = ".id")]
    pub id: String,
    pub comment: String,
    #[serde(deserialize_with = "deserialize_bool")]
    pub disabled: bool,
    #[serde(rename = "listen-port", deserialize_with = "deserialize_u16")]
    pub listen_port: u16,
    #[serde(deserialize_with = "deserialize_u16")]
    pub mtu: u16,
    pub name: String,
    #[serde(rename = "private-key")]
    pub private_key: String,
    #[serde(rename = "public-key")]
    pub public_key: String,
    #[serde(deserialize_with = "deserialize_bool")]
    pub running: bool,
}