1
=== added file 'src/maasserver/networking_preseed.py'
2
--- src/maasserver/networking_preseed.py	1970-01-01 00:00:00 +0000
3
+++ src/maasserver/networking_preseed.py	2014-09-24 02:49:10 +0000
4
@@ -0,0 +1,121 @@
5
1
# Copyright 2014 Canonical Ltd.  This software is licensed under the
6
2
# GNU Affero General Public License version 3 (see the file LICENSE).
7
3
8
4
"""Network configuration preseed code.
9
5
10
6
This will eventually generate installer networking configuration like:
11
7
12
8
   https://gist.github.com/jayofdoom/b035067523defec7fb53
13
9
14
10
The installer running on a node will use this to set up the node's networking
15
11
according to MAAS's specifications.
16
12
"""
17
13
18
14
from __future__ import (
19
15
    absolute_import,
20
16
    print_function,
21
17
    unicode_literals,
22
18
    )
23
19
24
20
str = None
25
21
26
22
__metaclass__ = type
27
23
__all__ = [
28
24
    'generate_networking_config',
29
25
    ]
30
26
31
27
from lxml import etree
32
28
from maasserver.models.nodeprobeddetails import get_probed_details
33
29
34
30
35
31
def extract_network_interface_data(element):
36
32
    """Extract network interface name and MAC address from XML element.
37
33
38
34
    :return: A tuple of network interface name and MAC address as found in
39
35
        the XML.  If either is not found, it will be `None`.
40
36
    """
41
37
    interfaces = element.xpath("logicalname")
42
38
    macs = element.xpath("serial")
43
39
    if len(interfaces) == 0 or len(macs) == 0:
44
40
        # Not enough data.
45
41
        return None, None
46
42
    assert len(interfaces) == 1
47
43
    assert len(macs) == 1
48
44
    return interfaces[0].text, macs[0].text
49
45
50
46
51
47
def normalise_mac(mac):
52
48
    """Return a MAC's normalised representation.
53
49
54
50
    This doesn't actually parse all the different formats for writing MAC
55
51
    addresses, but it does eliminate case differences.  In practice, any MAC
56
52
    address this code is likely to will equal another version of itself after
57
53
    normalisation, even if they were originally different spellings.
58
54
    """
59
55
    return mac.strip().lower()
60
56
61
57
62
58
def extract_network_interfaces(node):
63
59
    """Extract network interfaces from node's `lshw` output.
64
60
65
61
    :param node: A `Node`.
66
62
    :return: A list of tuples describing the network interfaces.
67
63
        Each tuple consists of an interface name and a MAC address.
68
64
    """
69
65
    node_details = get_probed_details([node.system_id])
70
66
    if node.system_id not in node_details:
71
67
        return []
72
68
    lshw_xml = node_details[node.system_id].get('lshw')
73
69
    if lshw_xml is None:
74
70
        return []
75
71
    network_nodes = etree.fromstring(lshw_xml).xpath("//node[@id='network']")
76
72
    interfaces = [
77
73
        extract_network_interface_data(xml_node)
78
74
        for xml_node in network_nodes
79
75
        ]
80
76
    return [
81
77
        (interface, normalise_mac(mac))
82
78
        for interface, mac in interfaces
83
79
        if interface is not None and mac is not None
84
80
        ]
85
81
86
82
87
83
def generate_ethernet_link_entry(interface, mac):
88
84
    """Generate the `links` list entry for the given ethernet interface.
89
85
90
86
    :param interface: Network interface name, e.g. `eth0`.
91
87
    :param mac: MAC address, e.g. `00:11:22:33:44:55`.
92
88
    :return: A dict specifying the network interface, with keys
93
89
        `id`, `type`, and `ethernet_mac_address` (and possibly more).
94
90
    """
95
91
    return {
96
92
        'id': interface,
97
93
        'type': 'ethernet',
98
94
        'ethernet_mac_address': mac,
99
95
        }
100
96
101
97
102
98
def generate_networking_config(node):
103
99
    """Generate a networking preseed for `node`.
104
100
105
101
    :param node: A `Node`.
106
102
    :return: A dict along the lines of the example in
107
103
        https://gist.github.com/jayofdoom/b035067523defec7fb53 -- just
108
104
        json-encode it to get a file in that format.
109
105
    """
110
106
    interfaces = extract_network_interfaces(node)
111
107
    return {
112
108
        'provider': "MAAS",
113
109
        'network_info': {
114
110
            'services': [
115
111
                # List DNS servers here.
116
112
                ],
117
113
            'networks': [
118
114
                # Write network specs here.
119
115
                ],
120
116
            'links': [
121
117
                generate_ethernet_link_entry(interface, mac)
122
118
                for interface, mac in interfaces
123
119
                ],
124
120
            },
125
121
        }
126
0
122
127
=== added file 'src/maasserver/tests/test_networking_preseed.py'
128
--- src/maasserver/tests/test_networking_preseed.py	1970-01-01 00:00:00 +0000
129
+++ src/maasserver/tests/test_networking_preseed.py	2014-09-24 02:49:10 +0000
130
@@ -0,0 +1,263 @@
131
1
# Copyright 2014 Canonical Ltd.  This software is licensed under the
132
2
# GNU Affero General Public License version 3 (see the file LICENSE).
133
3
134
4
"""Tests for networking preseed code."""
135
5
136
6
from __future__ import (
137
7
    absolute_import,
138
8
    print_function,
139
9
    unicode_literals,
140
10
    )
141
11
142
12
str = None
143
13
144
14
__metaclass__ = type
145
15
__all__ = [
146
16
    ]
147
17
148
18
from maasserver import networking_preseed
149
19
from maasserver.networking_preseed import (
150
20
    extract_network_interfaces,
151
21
    generate_ethernet_link_entry,
152
22
    generate_networking_config,
153
23
    normalise_mac,
154
24
    )
155
25
from maasserver.testing.factory import factory
156
26
from maasserver.testing.testcase import MAASServerTestCase
157
27
from maastesting.matchers import MockCalledOnceWith
158
28
159
29
160
30
def make_denormalised_mac():
161
31
    return ' %s ' % factory.make_mac_address().upper()
162
32
163
33
164
34
class TestExtractNetworkInterfaces(MAASServerTestCase):
165
35
166
36
    def test__returns_nothing_if_no_lshw_output_found(self):
167
37
        node = factory.make_Node()
168
38
        self.assertEqual([], extract_network_interfaces(node))
169
39
170
40
    def test__returns_nothing_if_no_network_description_found_in_lshw(self):
171
41
        node = factory.make_Node()
172
42
        lshw_output = """
173
43
            <list xmlns:lldp="lldp" xmlns:lshw="lshw">
174
44
              <lshw:list>
175
45
              </lshw:list>
176
46
            </list>
177
47
            """
178
48
        factory.make_NodeResult_for_commissioning(
179
49
            node=node, name='00-maas-01-lshw.out', script_result=0,
180
50
            data=lshw_output.encode('ascii'))
181
51
        self.assertEqual([], extract_network_interfaces(node))
182
52
183
53
    def test__extracts_interface_data(self):
184
54
        node = factory.make_Node()
185
55
        interface = factory.make_name('eth')
186
56
        mac = factory.make_mac_address()
187
57
        lshw_output = """
188
58
            <node id="network" claimed="true" class="network">
189
59
             <logicalname>%(interface)s</logicalname>
190
60
             <serial>%(mac)s</serial>
191
61
            </node>
192
62
            """ % {'interface': interface, 'mac': mac}
193
63
        factory.make_NodeResult_for_commissioning(
194
64
            node=node, name='00-maas-01-lshw.out', script_result=0,
195
65
            data=lshw_output.encode('ascii'))
196
66
        self.assertEqual([(interface, mac)], extract_network_interfaces(node))
197
67
198
68
    def test__finds_network_interface_on_motherboard(self):
199
69
        node = factory.make_Node()
200
70
        interface = factory.make_name('eth')
201
71
        mac = factory.make_mac_address()
202
72
        # Stripped-down version of real lshw output:
203
73
        lshw_output = """
204
74
            <!-- generated by lshw-B.02.16 -->
205
75
            <list>
206
76
            <node id="mynode" claimed="true" class="system" handle="DMI:0002">
207
77
              <node id="core" claimed="true" class="bus" handle="DMI:0003">
208
78
               <description>Motherboard</description>
209
79
                <node id="pci" claimed="true" class="bridge" \
210
80
                      handle="PCIBUS:0000:00">
211
81
                 <description>Host bridge</description>
212
82
                  <node id="network" claimed="true" class="network" \
213
83
                      handle="PCI:0000:00:19.0">
214
84
                   <description>Ethernet interface</description>
215
85
                   <product>82566DM-2 Gigabit Network Connection</product>
216
86
                   <vendor>Intel Corporation</vendor>
217
87
                   <logicalname>%(interface)s</logicalname>
218
88
                   <serial>%(mac)s</serial>
219
89
                   <configuration>
220
90
                    <setting id="ip" value="10.99.99.1" />
221
91
                   </configuration>
222
92
                  </node>
223
93
                </node>
224
94
              </node>
225
95
            </node>
226
96
            </list>
227
97
            """ % {'interface': interface, 'mac': mac}
228
98
        factory.make_NodeResult_for_commissioning(
229
99
            node=node, name='00-maas-01-lshw.out', script_result=0,
230
100
            data=lshw_output.encode('ascii'))
231
101
        self.assertEqual([(interface, mac)], extract_network_interfaces(node))
232
102
233
103
    def test__finds_network_interface_on_pci_bus(self):
234
104
        node = factory.make_Node()
235
105
        interface = factory.make_name('eth')
236
106
        mac = factory.make_mac_address()
237
107
        # Stripped-down version of real lshw output:
238
108
        lshw_output = """
239
109
            <!-- generated by lshw-B.02.16 -->
240
110
            <list>
241
111
            <node id="mynode" claimed="true" class="system" handle="DMI:0002">
242
112
              <node id="core" claimed="true" class="bus" handle="DMI:0003">
243
113
               <description>Motherboard</description>
244
114
                <node id="pci" claimed="true" class="bridge" \
245
115
                    handle="PCIBUS:0000:00">
246
116
                 <description>Host bridge</description>
247
117
                  <node id="pci:2" claimed="true" class="bridge" \
248
118
                      handle="PCIBUS:0000:07">
249
119
                   <description>PCI bridge</description>
250
120
                    <node id="network" claimed="true" class="network" \
251
121
                        handle="PCI:0000:07:04.0">
252
122
                     <description>Ethernet interface</description>
253
123
                     <logicalname>%(interface)s</logicalname>
254
124
                     <serial>%(mac)s</serial>
255
125
                     <configuration>
256
126
                      <setting id="ip" value="192.168.1.114" />
257
127
                     </configuration>
258
128
                    </node>
259
129
                  </node>
260
130
                </node>
261
131
              </node>
262
132
            </node>
263
133
            </list>
264
134
            """ % {'interface': interface, 'mac': mac}
265
135
        factory.make_NodeResult_for_commissioning(
266
136
            node=node, name='00-maas-01-lshw.out', script_result=0,
267
137
            data=lshw_output.encode('ascii'))
268
138
        self.assertEqual([(interface, mac)], extract_network_interfaces(node))
269
139
270
140
    def test__ignores_nodes_without_interface_name(self):
271
141
        node = factory.make_Node()
272
142
        mac = factory.make_mac_address()
273
143
        lshw_output = """
274
144
            <node id="network" claimed="true" class="network">
275
145
             <serial>%s</serial>
276
146
            </node>
277
147
            """ % mac
278
148
        factory.make_NodeResult_for_commissioning(
279
149
            node=node, name='00-maas-01-lshw.out', script_result=0,
280
150
            data=lshw_output.encode('ascii'))
281
151
        self.assertEqual([], extract_network_interfaces(node))
282
152
283
153
    def test__ignores_nodes_without_mac(self):
284
154
        node = factory.make_Node()
285
155
        interface = factory.make_name('eth')
286
156
        lshw_output = """
287
157
            <node id="network" claimed="true" class="network">
288
158
             <logicalname>%s</logicalname>
289
159
            </node>
290
160
            """ % interface
291
161
        factory.make_NodeResult_for_commissioning(
292
162
            node=node, name='00-maas-01-lshw.out', script_result=0,
293
163
            data=lshw_output.encode('ascii'))
294
164
        self.assertEqual([], extract_network_interfaces(node))
295
165
296
166
    def test__normalises_mac(self):
297
167
        node = factory.make_Node()
298
168
        interface = factory.make_name('eth')
299
169
        mac = make_denormalised_mac()
300
170
        self.assertNotEqual(normalise_mac(mac), mac)
301
171
        lshw_output = """
302
172
            <node id="network" claimed="true" class="network">
303
173
             <logicalname>%(interface)s</logicalname>
304
174
             <serial>%(mac)s</serial>
305
175
            </node>
306
176
            """ % {'interface': interface, 'mac': mac}
307
177
        factory.make_NodeResult_for_commissioning(
308
178
            node=node, name='00-maas-01-lshw.out', script_result=0,
309
179
            data=lshw_output.encode('ascii'))
310
180
        [entry] = extract_network_interfaces(node)
311
181
        _, extracted_mac = entry
312
182
        self.assertEqual(normalise_mac(mac), extracted_mac)
313
183
314
184
315
185
class TestNormaliseMAC(MAASServerTestCase):
316
186
317
187
    def test__normalises_case(self):
318
188
        mac = factory.make_mac_address()
319
189
        self.assertEqual(
320
190
            normalise_mac(mac.lower()),
321
191
            normalise_mac(mac.upper()))
322
192
323
193
    def test__strips_whitespace(self):
324
194
        mac = factory.make_mac_address()
325
195
        self.assertEqual(
326
196
            normalise_mac(mac),
327
197
            normalise_mac(' %s ' % mac))
328
198
329
199
    def test__is_idempotent(self):
330
200
        mac = factory.make_mac_address()
331
201
        self.assertEqual(
332
202
            normalise_mac(mac),
333
203
            normalise_mac(normalise_mac(mac)))
334
204
335
205
336
206
class TestGenerateEthernetLinkEntry(MAASServerTestCase):
337
207
338
208
    def test__generates_dict(self):
339
209
        interface = factory.make_name('eth')
340
210
        mac = factory.make_mac_address()
341
211
        self.assertEqual(
342
212
            {
343
213
                'id': interface,
344
214
                'type': 'ethernet',
345
215
                'ethernet_mac_address': mac,
346
216
            },
347
217
            generate_ethernet_link_entry(interface, mac))
348
218
349
219
350
220
class TestGenerateNetworkingConfig(MAASServerTestCase):
351
221
352
222
    def patch_interfaces(self, interface_mac_pairs):
353
223
        patch = self.patch_autospec(
354
224
            networking_preseed, 'extract_network_interfaces')
355
225
        patch.return_value = interface_mac_pairs
356
226
        return patch
357
227
358
228
    def test__returns_config_dict(self):
359
229
        self.patch_interfaces([])
360
230
        config = generate_networking_config(factory.make_Node())
361
231
        self.assertIsInstance(config, dict)
362
232
        self.assertEqual("MAAS", config['provider'])
363
233
364
234
    def test__includes_links(self):
365
235
        node = factory.make_Node()
366
236
        interface = factory.make_name('eth')
367
237
        mac = factory.make_mac_address()
368
238
        patch = self.patch_interfaces([(interface, mac)])
369
239
370
240
        config = generate_networking_config(node)
371
241
372
242
        self.assertThat(patch, MockCalledOnceWith(node))
373
243
        self.assertEqual(
374
244
            [
375
245
                {
376
246
                    'id': interface,
377
247
                    'type': 'ethernet',
378
248
                    'ethernet_mac_address': mac,
379
249
                },
380
250
            ],
381
251
            config['network_info']['links'])
382
252
383
253
    def test__includes_networks(self):
384
254
        # This section is not yet implemented, so expect an empty list.
385
255
        self.patch_interfaces([])
386
256
        config = generate_networking_config(factory.make_Node())
387
257
        self.assertEqual([], config['network_info']['networks'])
388
258
389
259
    def test__includes_dns_servers(self):
390
260
        # This section is not yet implemented, so expect an empty list.
391
261
        self.patch_interfaces([])
392
262
        config = generate_networking_config(factory.make_Node())
393
263
        self.assertEqual([], config['network_info']['services'])
Status:	Merged
Approved by:	Jeroen T. Vermeulen on 2014-09-24
Approved revision:	no longer in the source branch.
Merged at revision:	3068
Proposed branch:	lp:~jtv/maas/generate-node-networking-config-1
Merge into:	lp:~maas-committers/maas/trunk
Diff against target:	393 lines (+384/-0) 2 files modified src/maasserver/networking_preseed.py (+121/-0) src/maasserver/tests/test_networking_preseed.py (+263/-0)
To merge this branch:	bzr merge lp:~jtv/maas/generate-node-networking-config-1
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Graham Binns (community)		2014-09-12	Approve on 2014-09-12
Review via email: mp+234413@code.launchpad.net