nmstate 2.2.60

Library for networking management in a declarative manner
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

// SPDX-License-Identifier: Apache-2.0

use serde::{Deserialize, Serialize};

use crate::{BaseInterface, ErrorKind, InterfaceType, NmstateError};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
/// Linux kernel MAC VLAN interface. The example yaml output of
/// [crate::NetworkState] with a mac vlan interface would be:
/// ```yaml
/// ---
/// interfaces:
///   - name: mac0
///     type: mac-vlan
///     state: up
///     mac-vlan:
///       base-iface: eth1
///       mode: vepa
///       promiscuous: true
/// ```
pub struct MacVlanInterface {
    #[serde(flatten)]
    pub base: BaseInterface,
    #[serde(skip_serializing_if = "Option::is_none", rename = "mac-vlan")]
    /// Deserialize and serialize from/to `mac-vlan`.
    pub mac_vlan: Option<MacVlanConfig>,
}

impl Default for MacVlanInterface {
    fn default() -> Self {
        Self {
            base: BaseInterface {
                iface_type: InterfaceType::MacVlan,
                ..Default::default()
            },
            mac_vlan: None,
        }
    }
}

impl MacVlanInterface {
    pub fn new() -> Self {
        Self::default()
    }

    pub(crate) fn sanitize(
        &self,
        is_desired: bool,
    ) -> Result<(), NmstateError> {
        if is_desired
            && let Some(conf) = &self.mac_vlan
            && conf.accept_all_mac == Some(false)
            && conf.mode != MacVlanMode::Passthru
        {
            let e = NmstateError::new(
                ErrorKind::InvalidArgument,
                "Disable accept-all-mac-addresses(promiscuous) is only \
                 allowed on passthru mode"
                    .to_string(),
            );
            log::error!("{e}");
            return Err(e);
        }
        Ok(())
    }

    pub(crate) fn parent(&self) -> Option<&str> {
        self.mac_vlan.as_ref().map(|cfg| cfg.base_iface.as_str())
    }

    pub(crate) fn change_parent_name(&mut self, name: &str) {
        if let Some(mac_vlan_conf) = self.mac_vlan.as_mut() {
            mac_vlan_conf.base_iface = name.to_string();
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "kebab-case", deny_unknown_fields)]
#[non_exhaustive]
pub struct MacVlanConfig {
    pub base_iface: String,
    pub mode: MacVlanMode,
    #[serde(
        skip_serializing_if = "Option::is_none",
        rename = "promiscuous",
        alias = "accept-all-mac",
        default,
        deserialize_with = "crate::deserializer::option_bool_or_string"
    )]
    /// Serialize to `promiscuous`.
    /// Deserialize from `promiscuous` or `accept-all-mac`.
    pub accept_all_mac: Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
#[derive(Default)]
pub enum MacVlanMode {
    /// Deserialize and serialize from/to `vepa`.
    Vepa,
    /// Deserialize and serialize from/to `bridge`.
    Bridge,
    /// Deserialize and serialize from/to `private`.
    Private,
    /// Deserialize and serialize from/to `passthru`.
    Passthru,
    /// Deserialize and serialize from/to `source`.
    Source,
    #[default]
    Unknown,
}

impl From<MacVlanMode> for u32 {
    fn from(v: MacVlanMode) -> u32 {
        match v {
            MacVlanMode::Unknown => 0,
            MacVlanMode::Vepa => 1,
            MacVlanMode::Bridge => 2,
            MacVlanMode::Private => 3,
            MacVlanMode::Passthru => 4,
            MacVlanMode::Source => 5,
        }
    }
}