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
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
153
154
155
156
157
158
159
160
161
162
163
164
165

// SPDX-License-Identifier: Apache-2.0

use crate::{ErrorKind, Interfaces, MergedInterfaces};

#[test]
fn test_hsr_port_cannot_have_ip_enabled_explicitly() {
    let des_ifaces: Interfaces = serde_yaml::from_str(
        r"---
        - name: hsr0
          type: hsr
          state: up
          hsr:
            port1: eth1
            port2: eth2
            protocol: prp
            multicast-spec: 40
        - name: eth1
          type: ethernet
          state: up
          ipv4:
            enabled: true
            dhcp: true
          ipv6:
            enabled: true
            dhcp: true
            autoconf: true",
    )
    .unwrap();
    let cur_ifaces: Interfaces = serde_yaml::from_str(
        r"---
        - name: eth1
          type: ethernet
        - name: eth2
          type: ethernet
        ",
    )
    .unwrap();

    let result = MergedInterfaces::new(
        des_ifaces,
        cur_ifaces,
        Default::default(),
        false,
    );

    assert!(result.is_err());

    if let Err(e) = result {
        assert_eq!(e.kind(), ErrorKind::InvalidArgument);
        assert!(e.msg().contains("hsr0"));
        assert!(e.msg().contains("eth1"));
    }
}

#[test]
fn test_auto_include_hsr_port_as_changed() {
    let des_ifaces: Interfaces = serde_yaml::from_str(
        r"---
        - name: hsr0
          type: hsr
          state: up
          hsr:
            port1: eth1
            port2: eth2
            protocol: prp
            multicast-spec: 40",
    )
    .unwrap();
    let cur_ifaces: Interfaces = serde_yaml::from_str(
        r"---
        - name: eth1
          type: ethernet
          ipv4:
            enabled: true
            dhcp: true
          ipv6:
            enabled: true
            dhcp: true
            autoconf: true
        - name: eth2
          type: ethernet
          ipv4:
            enabled: true
            dhcp: true
          ipv6:
            enabled: true
            dhcp: true
            autoconf: true
        ",
    )
    .unwrap();

    let merged_ifaces = MergedInterfaces::new(
        des_ifaces,
        cur_ifaces,
        Default::default(),
        false,
    )
    .unwrap();

    let port1 = merged_ifaces.kernel_ifaces["eth1"]
        .for_apply
        .as_ref()
        .unwrap();
    let port2 = merged_ifaces.kernel_ifaces["eth2"]
        .for_apply
        .as_ref()
        .unwrap();

    assert_eq!(
        port1.base_iface().ipv4.as_ref().map(|i| i.enabled),
        Some(false)
    );
    assert_eq!(
        port1.base_iface().ipv6.as_ref().map(|i| i.enabled),
        Some(false)
    );
    assert_eq!(
        port2.base_iface().ipv4.as_ref().map(|i| i.enabled),
        Some(false)
    );
    assert_eq!(
        port2.base_iface().ipv6.as_ref().map(|i| i.enabled),
        Some(false)
    );
}

#[test]
fn test_prp_interlink_is_forbidden() {
    let cur_ifaces: Interfaces = serde_yaml::from_str(
        r"---
      - name: eth1
        type: ethernet
      - name: eth2
        type: ethernet
      - name: eth3
        type: ethernet
      ",
    )
    .unwrap();
    let des_ifaces = serde_yaml::from_str(
        r"---
        - name: hsr0
          type: hsr
          state: up
          hsr:
            port1: eth1
            port2: eth2
            interlink: eth3
            protocol: prp
            multicast-spec: 40",
    )
    .unwrap();

    let err = MergedInterfaces::new(
        des_ifaces,
        cur_ifaces,
        Default::default(),
        false,
    )
    .unwrap_err();

    assert_eq!(err.kind(), ErrorKind::InvalidArgument);
    assert!(err.msg().contains("interlink property is not supported"));
}