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

// SPDX-License-Identifier: Apache-2.0

use super::super::nm_dbus::{NmConnection, NmSettingVlanFlag};
use crate::{VlanInterface, VlanProtocol, VlanRegistrationProtocol};

const NM_802_1_AD: &str = "802.1ad";
const NM_802_1_Q: &str = "802.1Q";

pub(crate) fn gen_nm_vlan_setting(
    iface: &VlanInterface,
    nm_conn: &mut NmConnection,
) {
    if let Some(vlan_conf) = iface.vlan.as_ref() {
        let mut nm_vlan = nm_conn.vlan.as_ref().cloned().unwrap_or_default();
        nm_vlan.id = Some(vlan_conf.id.into());
        nm_vlan.parent = vlan_conf.base_iface.clone();
        if let Some(protocol) = vlan_conf.protocol {
            match protocol {
                VlanProtocol::Ieee8021Ad => {
                    nm_vlan.protocol = Some(NM_802_1_AD.to_string());
                }
                VlanProtocol::Ieee8021Q => {
                    nm_vlan.protocol = Some(NM_802_1_Q.to_string());
                }
            }
        }

        if let Some(registration_protocol) = vlan_conf.registration_protocol {
            match registration_protocol {
                VlanRegistrationProtocol::Gvrp => {
                    nm_vlan
                        .flags
                        .retain(|x| !matches!(x, NmSettingVlanFlag::Mvrp));
                    nm_vlan.flags.push(NmSettingVlanFlag::Gvrp);
                }
                VlanRegistrationProtocol::Mvrp => {
                    nm_vlan
                        .flags
                        .retain(|x| !matches!(x, NmSettingVlanFlag::Gvrp));
                    nm_vlan.flags.push(NmSettingVlanFlag::Mvrp);
                }
                VlanRegistrationProtocol::None => {
                    nm_vlan.flags.retain(|x| {
                        !matches!(
                            x,
                            NmSettingVlanFlag::Gvrp | NmSettingVlanFlag::Mvrp,
                        )
                    });
                }
            }
        }

        if let Some(reorder_headers) = vlan_conf.reorder_headers {
            if reorder_headers {
                nm_vlan.flags.push(NmSettingVlanFlag::ReorderHeaders);
            } else {
                nm_vlan.flags.retain(|x| {
                    !matches!(x, NmSettingVlanFlag::ReorderHeaders)
                });
            }
        }

        if let Some(loose_binding) = vlan_conf.loose_binding {
            if loose_binding {
                nm_vlan.flags.push(NmSettingVlanFlag::LooseBinding);
            } else {
                nm_vlan
                    .flags
                    .retain(|x| !matches!(x, NmSettingVlanFlag::LooseBinding));
            }
        }

        if let Some(ingress_maps) = vlan_conf.ingress_qos_map.as_deref() {
            nm_vlan.ingress_priority_map =
                ingress_maps.iter().map(|m| m.to_string()).collect();
        }
        if let Some(egress_maps) = vlan_conf.egress_qos_map.as_deref() {
            nm_vlan.egress_priority_map =
                egress_maps.iter().map(|m| m.to_string()).collect();
        }

        nm_conn.vlan = Some(nm_vlan);
    }
}