1
diff --git a/cloudinit/sources/DataSourceAzure.py b/cloudinit/sources/DataSourceAzure.py
2
index be82ec4..e076d5d 100644
3
--- a/cloudinit/sources/DataSourceAzure.py
4
+++ b/cloudinit/sources/DataSourceAzure.py
5
@@ -22,6 +22,7 @@ from cloudinit.event import EventType
6
22
from cloudinit.net.dhcp import EphemeralDHCPv4
22
from cloudinit.net.dhcp import EphemeralDHCPv4
7
23
from cloudinit import sources
23
from cloudinit import sources
8
24
from cloudinit.sources.helpers.azure import get_metadata_from_fabric
24
from cloudinit.sources.helpers.azure import get_metadata_from_fabric
9
25
from cloudinit.sources.helpers import netlink
10
25
from cloudinit.url_helper import UrlError, readurl, retry_on_url_exc
26
from cloudinit.url_helper import UrlError, readurl, retry_on_url_exc
11
26
from cloudinit import util
27
from cloudinit import util
12
27
28
13
@@ -409,6 +410,10 @@ class DataSourceAzure(sources.DataSource):
14
409
410
15
410
            perform_reprovision = reprovision or self._should_reprovision(ret)
411
            perform_reprovision = reprovision or self._should_reprovision(ret)
16
411
            if perform_reprovision:
412
            if perform_reprovision:
17
413
                if util.is_FreeBSD():
18
414
                    msg = "Free BSD is not supported for PPS VMs"
19
415
                    LOG.error(msg)
20
416
                    raise sources.InvalidMetaDataException(msg)
21
412
                ret = self._reprovision()
417
                ret = self._reprovision()
22
413
            imds_md = get_metadata_from_imds(
418
            imds_md = get_metadata_from_imds(
23
414
                self.fallback_interface, retries=3)
419
                self.fallback_interface, retries=3)
24
@@ -523,8 +528,8 @@ class DataSourceAzure(sources.DataSource):
25
523
        response. Then return the returned JSON object."""
528
        response. Then return the returned JSON object."""
26
524
        url = IMDS_URL + "reprovisiondata?api-version=2017-04-02"
529
        url = IMDS_URL + "reprovisiondata?api-version=2017-04-02"
27
525
        headers = {"Metadata": "true"}
530
        headers = {"Metadata": "true"}
28
531
        nl_sock = None
29
526
        report_ready = bool(not os.path.isfile(REPORTED_READY_MARKER_FILE))
532
        report_ready = bool(not os.path.isfile(REPORTED_READY_MARKER_FILE))
30
527
        LOG.debug("Start polling IMDS")
31
528
533
32
529
        def exc_cb(msg, exception):
534
        def exc_cb(msg, exception):
33
530
            if isinstance(exception, UrlError) and exception.code == 404:
535
            if isinstance(exception, UrlError) and exception.code == 404:
34
@@ -533,12 +538,19 @@ class DataSourceAzure(sources.DataSource):
35
533
            # call DHCP and setup the ephemeral network to acquire the new IP.
538
            # call DHCP and setup the ephemeral network to acquire the new IP.
36
534
            return False
539
            return False
37
535
540
38
541
        LOG.debug("Wait for vnetswitch to happen")
39
536
        while True:
542
        while True:
40
537
            try:
543
            try:
41
538
                # Save our EphemeralDHCPv4 context so we avoid repeated dhcp
544
                # Save our EphemeralDHCPv4 context so we avoid repeated dhcp
42
539
                self._ephemeral_dhcp_ctx = EphemeralDHCPv4()
545
                self._ephemeral_dhcp_ctx = EphemeralDHCPv4()
43
540
                lease = self._ephemeral_dhcp_ctx.obtain_lease()
546
                lease = self._ephemeral_dhcp_ctx.obtain_lease()
44
541
                if report_ready:
547
                if report_ready:
45
548
                    try:
46
549
                        nl_sock = netlink.create_bound_netlink_socket()
47
550
                    except netlink.NetlinkCreateSocketError as e:
48
551
                        LOG.warning(e)
49
552
                        self._ephemeral_dhcp_ctx.clean_network()
50
553
                        return
51
542
                    path = REPORTED_READY_MARKER_FILE
554
                    path = REPORTED_READY_MARKER_FILE
52
543
                    LOG.info(
555
                    LOG.info(
53
544
                        "Creating a marker file to report ready: %s", path)
556
                        "Creating a marker file to report ready: %s", path)
54
@@ -546,13 +558,24 @@ class DataSourceAzure(sources.DataSource):
55
546
                        pid=os.getpid(), time=time()))
558
                        pid=os.getpid(), time=time()))
56
547
                    self._report_ready(lease=lease)
559
                    self._report_ready(lease=lease)
57
548
                    report_ready = False
560
                    report_ready = False
61
549
                return readurl(url, timeout=1, headers=headers,
561
                    try:
62
550
                               exception_cb=exc_cb, infinite=True,
562
                        netlink.wait_for_media_disconnect_connect(
63
551
                               log_req_resp=False).contents
563
                            nl_sock, lease['interface'])
64
564
                    except AssertionError as error:
65
565
                        LOG.error(error)
66
566
                        return
67
567
                    self._ephemeral_dhcp_ctx.clean_network()
68
568
                else:
69
569
                    return readurl(url, timeout=1, headers=headers,
70
570
                                   exception_cb=exc_cb, infinite=True,
71
571
                                   log_req_resp=False).contents
72
552
            except UrlError:
572
            except UrlError:
73
553
                # Teardown our EphemeralDHCPv4 context on failure as we retry
573
                # Teardown our EphemeralDHCPv4 context on failure as we retry
74
554
                self._ephemeral_dhcp_ctx.clean_network()
574
                self._ephemeral_dhcp_ctx.clean_network()
75
555
                pass
575
                pass
76
576
            finally:
77
577
                if nl_sock:
78
578
                    nl_sock.close()
79
556
579
80
557
    def _report_ready(self, lease):
580
    def _report_ready(self, lease):
81
558
        """Tells the fabric provisioning has completed """
581
        """Tells the fabric provisioning has completed """
82
diff --git a/cloudinit/sources/helpers/netlink.py b/cloudinit/sources/helpers/netlink.py
83
559
new file mode 100644
582
new file mode 100644
84
index 0000000..d377ae3
85
--- /dev/null
86
+++ b/cloudinit/sources/helpers/netlink.py
87
@@ -0,0 +1,250 @@
88
1
# Author: Tamilmani Manoharan <tamanoha@microsoft.com>
89
2
#
90
3
# This file is part of cloud-init. See LICENSE file for license information.
91
4
92
5
from cloudinit import log as logging
93
6
from cloudinit import util
94
7
from collections import namedtuple
95
8
96
9
import os
97
10
import select
98
11
import socket
99
12
import struct
100
13
101
14
LOG = logging.getLogger(__name__)
102
15
103
16
# http://man7.org/linux/man-pages/man7/netlink.7.html
104
17
RTMGRP_LINK = 1
105
18
NLMSG_NOOP = 1
106
19
NLMSG_ERROR = 2
107
20
NLMSG_DONE = 3
108
21
RTM_NEWLINK = 16
109
22
RTM_DELLINK = 17
110
23
RTM_GETLINK = 18
111
24
RTM_SETLINK = 19
112
25
MAX_SIZE = 65535
113
26
RTA_DATA_OFFSET = 32
114
27
MSG_TYPE_OFFSET = 16
115
28
SELECT_TIMEOUT = 60
116
29
117
30
NLMSGHDR_FMT = "IHHII"
118
31
IFINFOMSG_FMT = "BHiII"
119
32
NLMSGHDR_SIZE = struct.calcsize(NLMSGHDR_FMT)
120
33
IFINFOMSG_SIZE = struct.calcsize(IFINFOMSG_FMT)
121
34
RTATTR_START_OFFSET = NLMSGHDR_SIZE + IFINFOMSG_SIZE
122
35
RTA_DATA_START_OFFSET = 4
123
36
PAD_ALIGNMENT = 4
124
37
125
38
IFLA_IFNAME = 3
126
39
IFLA_OPERSTATE = 16
127
40
128
41
# https://www.kernel.org/doc/Documentation/networking/operstates.txt
129
42
OPER_UNKNOWN = 0
130
43
OPER_NOTPRESENT = 1
131
44
OPER_DOWN = 2
132
45
OPER_LOWERLAYERDOWN = 3
133
46
OPER_TESTING = 4
134
47
OPER_DORMANT = 5
135
48
OPER_UP = 6
136
49
137
50
RTAAttr = namedtuple('RTAAttr', ['length', 'rta_type', 'data'])
138
51
InterfaceOperstate = namedtuple('InterfaceOperstate', ['ifname', 'operstate'])
139
52
NetlinkHeader = namedtuple('NetlinkHeader', ['length', 'type', 'flags', 'seq',
140
53
                                             'pid'])
141
54
142
55
143
56
class NetlinkCreateSocketError(RuntimeError):
144
57
    '''Raised if netlink socket fails during create or bind.'''
145
58
    pass
146
59
147
60
148
61
def create_bound_netlink_socket():
149
62
    '''Creates netlink socket and bind on netlink group to catch interface
150
63
    down/up events. The socket will bound only on RTMGRP_LINK (which only
151
64
    includes RTM_NEWLINK/RTM_DELLINK/RTM_GETLINK events). The socket is set to
152
65
    non-blocking mode since we're only receiving messages.
153
66
154
67
    :returns: netlink socket in non-blocking mode
155
68
    :raises: NetlinkCreateSocketError
156
69
    '''
157
70
    try:
158
71
        netlink_socket = socket.socket(socket.AF_NETLINK,
159
72
                                       socket.SOCK_RAW,
160
73
                                       socket.NETLINK_ROUTE)
161
74
        netlink_socket.bind((os.getpid(), RTMGRP_LINK))
162
75
        netlink_socket.setblocking(0)
163
76
    except socket.error as e:
164
77
        msg = "Exception during netlink socket create: %s" % e
165
78
        raise NetlinkCreateSocketError(msg)
166
79
    LOG.debug("Created netlink socket")
167
80
    return netlink_socket
168
81
169
82
170
83
def get_netlink_msg_header(data):
171
84
    '''Gets netlink message type and length
172
85
173
86
    :param: data read from netlink socket
174
87
    :returns: netlink message type
175
88
    :raises: AssertionError if data is None or data is not >= NLMSGHDR_SIZE
176
89
    struct nlmsghdr {
177
90
               __u32 nlmsg_len;    /* Length of message including header */
178
91
               __u16 nlmsg_type;   /* Type of message content */
179
92
               __u16 nlmsg_flags;  /* Additional flags */
180
93
               __u32 nlmsg_seq;    /* Sequence number */
181
94
               __u32 nlmsg_pid;    /* Sender port ID */
182
95
    };
183
96
    '''
184
97
    assert (data is not None), ("data is none")
185
98
    assert (len(data) >= NLMSGHDR_SIZE), (
186
99
        "data is smaller than netlink message header")
187
100
    msg_len, msg_type, flags, seq, pid = struct.unpack(NLMSGHDR_FMT,
188
101
                                                       data[:MSG_TYPE_OFFSET])
189
102
    LOG.debug("Got netlink msg of type %d", msg_type)
190
103
    return NetlinkHeader(msg_len, msg_type, flags, seq, pid)
191
104
192
105
193
106
def read_netlink_socket(netlink_socket, timeout=None):
194
107
    '''Select and read from the netlink socket if ready.
195
108
196
109
    :param: netlink_socket: specify which socket object to read from
197
110
    :param: timeout: specify a timeout value (integer) to wait while reading,
198
111
            if none, it will block indefinitely until socket ready for read
199
112
    :returns: string of data read (max length = <MAX_SIZE>) from socket,
200
113
              if no data read, returns None
201
114
    :raises: AssertionError if netlink_socket is None
202
115
    '''
203
116
    assert (netlink_socket is not None), ("netlink socket is none")
204
117
    read_set, _, _ = select.select([netlink_socket], [], [], timeout)
205
118
    # Incase of timeout,read_set doesn't contain netlink socket.
206
119
    # just return from this function
207
120
    if netlink_socket not in read_set:
208
121
        return None
209
122
    LOG.debug("netlink socket ready for read")
210
123
    data = netlink_socket.recv(MAX_SIZE)
211
124
    if data is None:
212
125
        LOG.error("Reading from Netlink socket returned no data")
213
126
    return data
214
127
215
128
216
129
def unpack_rta_attr(data, offset):
217
130
    '''Unpack a single rta attribute.
218
131
219
132
    :param: data: string of data read from netlink socket
220
133
    :param: offset: starting offset of RTA Attribute
221
134
    :return: RTAAttr object with length, type and data. On error, return None.
222
135
    :raises: AssertionError if data is None or offset is not integer.
223
136
    '''
224
137
    assert (data is not None), ("data is none")
225
138
    assert (type(offset) == int), ("offset is not integer")
226
139
    assert (offset >= RTATTR_START_OFFSET), (
227
140
        "rta offset is less than expected length")
228
141
    length = rta_type = 0
229
142
    attr_data = None
230
143
    try:
231
144
        length = struct.unpack_from("H", data, offset=offset)[0]
232
145
        rta_type = struct.unpack_from("H", data, offset=offset+2)[0]
233
146
    except struct.error:
234
147
        return None  # Should mean our offset is >= remaining data
235
148
236
149
    # Unpack just the attribute's data. Offset by 4 to skip length/type header
237
150
    attr_data = data[offset+RTA_DATA_START_OFFSET:offset+length]
238
151
    return RTAAttr(length, rta_type, attr_data)
239
152
240
153
241
154
def read_rta_oper_state(data):
242
155
    '''Reads Interface name and operational state from RTA Data.
243
156
244
157
    :param: data: string of data read from netlink socket
245
158
    :returns: InterfaceOperstate object containing if_name and oper_state.
246
159
              None if data does not contain valid IFLA_OPERSTATE and
247
160
              IFLA_IFNAME messages.
248
161
    :raises: AssertionError if data is None or length of data is
249
162
             smaller than RTATTR_START_OFFSET.
250
163
    '''
251
164
    assert (data is not None), ("data is none")
252
165
    assert (len(data) > RTATTR_START_OFFSET), (
253
166
        "length of data is smaller than RTATTR_START_OFFSET")
254
167
    ifname = operstate = None
255
168
    offset = RTATTR_START_OFFSET
256
169
    while offset <= len(data):
257
170
        attr = unpack_rta_attr(data, offset)
258
171
        if not attr or attr.length == 0:
259
172
            break
260
173
        # Each attribute is 4-byte aligned. Determine pad length.
261
174
        padlen = (PAD_ALIGNMENT -
262
175
                  (attr.length % PAD_ALIGNMENT)) % PAD_ALIGNMENT
263
176
        offset += attr.length + padlen
264
177
265
178
        if attr.rta_type == IFLA_OPERSTATE:
266
179
            operstate = ord(attr.data)
267
180
        elif attr.rta_type == IFLA_IFNAME:
268
181
            interface_name = util.decode_binary(attr.data, 'utf-8')
269
182
            ifname = interface_name.strip('\0')
270
183
    if not ifname or operstate is None:
271
184
        return None
272
185
    LOG.debug("rta attrs: ifname %s operstate %d", ifname, operstate)
273
186
    return InterfaceOperstate(ifname, operstate)
274
187
275
188
276
189
def wait_for_media_disconnect_connect(netlink_socket, ifname):
277
190
    '''Block until media disconnect and connect has happened on an interface.
278
191
    Listens on netlink socket to receive netlink events and when the carrier
279
192
    changes from 0 to 1, it considers event has happened and
280
193
    return from this function
281
194
282
195
    :param: netlink_socket: netlink_socket to receive events
283
196
    :param: ifname: Interface name to lookout for netlink events
284
197
    :raises: AssertionError if netlink_socket is None or ifname is None.
285
198
    '''
286
199
    assert (netlink_socket is not None), ("netlink socket is none")
287
200
    assert (ifname is not None), ("interface name is none")
288
201
    assert (len(ifname) > 0), ("interface name cannot be empty")
289
202
    carrier = OPER_UP
290
203
    prevCarrier = OPER_UP
291
204
    data = bytes()
292
205
    LOG.debug("Wait for media disconnect and reconnect to happen")
293
206
    while True:
294
207
        recv_data = read_netlink_socket(netlink_socket, SELECT_TIMEOUT)
295
208
        if recv_data is None:
296
209
            continue
297
210
        LOG.debug('read %d bytes from socket', len(recv_data))
298
211
        data += recv_data
299
212
        LOG.debug('Length of data after concat %d', len(data))
300
213
        offset = 0
301
214
        datalen = len(data)
302
215
        while offset < datalen:
303
216
            nl_msg = data[offset:]
304
217
            if len(nl_msg) < NLMSGHDR_SIZE:
305
218
                LOG.debug("Data is smaller than netlink header")
306
219
                break
307
220
            nlheader = get_netlink_msg_header(nl_msg)
308
221
            if len(nl_msg) < nlheader.length:
309
222
                LOG.debug("Partial data. Smaller than netlink message")
310
223
                break
311
224
            padlen = (nlheader.length+PAD_ALIGNMENT-1) & ~(PAD_ALIGNMENT-1)
312
225
            offset = offset + padlen
313
226
            LOG.debug('offset to next netlink message: %d', offset)
314
227
            # Ignore any messages not new link or del link
315
228
            if nlheader.type not in [RTM_NEWLINK, RTM_DELLINK]:
316
229
                continue
317
230
            interface_state = read_rta_oper_state(nl_msg)
318
231
            if interface_state is None:
319
232
                LOG.debug('Failed to read rta attributes: %s', interface_state)
320
233
                continue
321
234
            if interface_state.ifname != ifname:
322
235
                LOG.debug(
323
236
                    "Ignored netlink event on interface %s. Waiting for %s.",
324
237
                    interface_state.ifname, ifname)
325
238
                continue
326
239
            if interface_state.operstate not in [OPER_UP, OPER_DOWN]:
327
240
                continue
328
241
            prevCarrier = carrier
329
242
            carrier = interface_state.operstate
330
243
            # check for carrier down, up sequence
331
244
            isVnetSwitch = (prevCarrier == OPER_DOWN) and (carrier == OPER_UP)
332
245
            if isVnetSwitch:
333
246
                LOG.debug("Media switch happened on %s.", ifname)
334
247
                return
335
248
        data = data[offset:]
336
249
337
250
# vi: ts=4 expandtab
338
diff --git a/cloudinit/sources/helpers/tests/test_netlink.py b/cloudinit/sources/helpers/tests/test_netlink.py
339
0
new file mode 100644
251
new file mode 100644
340
index 0000000..c2898a1
341
--- /dev/null
342
+++ b/cloudinit/sources/helpers/tests/test_netlink.py
343
@@ -0,0 +1,373 @@
344
1
# Author: Tamilmani Manoharan <tamanoha@microsoft.com>
345
2
#
346
3
# This file is part of cloud-init. See LICENSE file for license information.
347
4
348
5
from cloudinit.tests.helpers import CiTestCase, mock
349
6
import socket
350
7
import struct
351
8
import codecs
352
9
from cloudinit.sources.helpers.netlink import (
353
10
    NetlinkCreateSocketError, create_bound_netlink_socket, read_netlink_socket,
354
11
    read_rta_oper_state, unpack_rta_attr, wait_for_media_disconnect_connect,
355
12
    OPER_DOWN, OPER_UP, OPER_DORMANT, OPER_LOWERLAYERDOWN, OPER_NOTPRESENT,
356
13
    OPER_TESTING, OPER_UNKNOWN, RTATTR_START_OFFSET, RTM_NEWLINK, RTM_SETLINK,
357
14
    RTM_GETLINK, MAX_SIZE)
358
15
359
16
360
17
def int_to_bytes(i):
361
18
    '''convert integer to binary: eg: 1 to \x01'''
362
19
    hex_value = '{0:x}'.format(i)
363
20
    hex_value = '0' * (len(hex_value) % 2) + hex_value
364
21
    return codecs.decode(hex_value, 'hex_codec')
365
22
366
23
367
24
class TestCreateBoundNetlinkSocket(CiTestCase):
368
25
369
26
    @mock.patch('cloudinit.sources.helpers.netlink.socket.socket')
370
27
    def test_socket_error_on_create(self, m_socket):
371
28
        '''create_bound_netlink_socket catches socket creation exception'''
372
29
373
30
        """NetlinkCreateSocketError is raised when socket creation errors."""
374
31
        m_socket.side_effect = socket.error("Fake socket failure")
375
32
        with self.assertRaises(NetlinkCreateSocketError) as ctx_mgr:
376
33
            create_bound_netlink_socket()
377
34
        self.assertEqual(
378
35
            'Exception during netlink socket create: Fake socket failure',
379
36
            str(ctx_mgr.exception))
380
37
381
38
382
39
class TestReadNetlinkSocket(CiTestCase):
383
40
384
41
    @mock.patch('cloudinit.sources.helpers.netlink.socket.socket')
385
42
    @mock.patch('cloudinit.sources.helpers.netlink.select.select')
386
43
    def test_read_netlink_socket(self, m_select, m_socket):
387
44
        '''read_netlink_socket able to receive data'''
388
45
        data = 'netlinktest'
389
46
        m_select.return_value = [m_socket], None, None
390
47
        m_socket.recv.return_value = data
391
48
        recv_data = read_netlink_socket(m_socket, 2)
392
49
        m_select.assert_called_with([m_socket], [], [], 2)
393
50
        m_socket.recv.assert_called_with(MAX_SIZE)
394
51
        self.assertIsNotNone(recv_data)
395
52
        self.assertEqual(recv_data, data)
396
53
397
54
    @mock.patch('cloudinit.sources.helpers.netlink.socket.socket')
398
55
    @mock.patch('cloudinit.sources.helpers.netlink.select.select')
399
56
    def test_netlink_read_timeout(self, m_select, m_socket):
400
57
        '''read_netlink_socket should timeout if nothing to read'''
401
58
        m_select.return_value = [], None, None
402
59
        data = read_netlink_socket(m_socket, 1)
403
60
        m_select.assert_called_with([m_socket], [], [], 1)
404
61
        self.assertEqual(m_socket.recv.call_count, 0)
405
62
        self.assertIsNone(data)
406
63
407
64
    def test_read_invalid_socket(self):
408
65
        '''read_netlink_socket raises assert error if socket is invalid'''
409
66
        socket = None
410
67
        with self.assertRaises(AssertionError) as context:
411
68
            read_netlink_socket(socket, 1)
412
69
        self.assertTrue('netlink socket is none' in str(context.exception))
413
70
414
71
415
72
class TestParseNetlinkMessage(CiTestCase):
416
73
417
74
    def test_read_rta_oper_state(self):
418
75
        '''read_rta_oper_state could parse netlink message and extract data'''
419
76
        ifname = "eth0"
420
77
        bytes = ifname.encode("utf-8")
421
78
        buf = bytearray(48)
422
79
        struct.pack_into("HH4sHHc", buf, RTATTR_START_OFFSET, 8, 3, bytes, 5,
423
80
                         16, int_to_bytes(OPER_DOWN))
424
81
        interface_state = read_rta_oper_state(buf)
425
82
        self.assertEqual(interface_state.ifname, ifname)
426
83
        self.assertEqual(interface_state.operstate, OPER_DOWN)
427
84
428
85
    def test_read_none_data(self):
429
86
        '''read_rta_oper_state raises assert error if data is none'''
430
87
        data = None
431
88
        with self.assertRaises(AssertionError) as context:
432
89
            read_rta_oper_state(data)
433
90
        self.assertTrue('data is none', str(context.exception))
434
91
435
92
    def test_read_invalid_rta_operstate_none(self):
436
93
        '''read_rta_oper_state returns none if operstate is none'''
437
94
        ifname = "eth0"
438
95
        buf = bytearray(40)
439
96
        bytes = ifname.encode("utf-8")
440
97
        struct.pack_into("HH4s", buf, RTATTR_START_OFFSET, 8, 3, bytes)
441
98
        interface_state = read_rta_oper_state(buf)
442
99
        self.assertIsNone(interface_state)
443
100
444
101
    def test_read_invalid_rta_ifname_none(self):
445
102
        '''read_rta_oper_state returns none if ifname is none'''
446
103
        buf = bytearray(40)
447
104
        struct.pack_into("HHc", buf, RTATTR_START_OFFSET, 5, 16,
448
105
                         int_to_bytes(OPER_DOWN))
449
106
        interface_state = read_rta_oper_state(buf)
450
107
        self.assertIsNone(interface_state)
451
108
452
109
    def test_read_invalid_data_len(self):
453
110
        '''raise assert error if data size is smaller than required size'''
454
111
        buf = bytearray(32)
455
112
        with self.assertRaises(AssertionError) as context:
456
113
            read_rta_oper_state(buf)
457
114
        self.assertTrue('length of data is smaller than RTATTR_START_OFFSET' in
458
115
                        str(context.exception))
459
116
460
117
    def test_unpack_rta_attr_none_data(self):
461
118
        '''unpack_rta_attr raises assert error if data is none'''
462
119
        data = None
463
120
        with self.assertRaises(AssertionError) as context:
464
121
            unpack_rta_attr(data, RTATTR_START_OFFSET)
465
122
        self.assertTrue('data is none' in str(context.exception))
466
123
467
124
    def test_unpack_rta_attr_invalid_offset(self):
468
125
        '''unpack_rta_attr raises assert error if offset is invalid'''
469
126
        data = bytearray(48)
470
127
        with self.assertRaises(AssertionError) as context:
471
128
            unpack_rta_attr(data, "offset")
472
129
        self.assertTrue('offset is not integer' in str(context.exception))
473
130
        with self.assertRaises(AssertionError) as context:
474
131
            unpack_rta_attr(data, 31)
475
132
        self.assertTrue('rta offset is less than expected length' in
476
133
                        str(context.exception))
477
134
478
135
479
136
@mock.patch('cloudinit.sources.helpers.netlink.socket.socket')
480
137
@mock.patch('cloudinit.sources.helpers.netlink.read_netlink_socket')
481
138
class TestWaitForMediaDisconnectConnect(CiTestCase):
482
139
    with_logs = True
483
140
484
141
    def _media_switch_data(self, ifname, msg_type, operstate):
485
142
        '''construct netlink data with specified fields'''
486
143
        if ifname and operstate is not None:
487
144
            data = bytearray(48)
488
145
            bytes = ifname.encode("utf-8")
489
146
            struct.pack_into("HH4sHHc", data, RTATTR_START_OFFSET, 8, 3,
490
147
                             bytes, 5, 16, int_to_bytes(operstate))
491
148
        elif ifname:
492
149
            data = bytearray(40)
493
150
            bytes = ifname.encode("utf-8")
494
151
            struct.pack_into("HH4s", data, RTATTR_START_OFFSET, 8, 3, bytes)
495
152
        elif operstate:
496
153
            data = bytearray(40)
497
154
            struct.pack_into("HHc", data, RTATTR_START_OFFSET, 5, 16,
498
155
                             int_to_bytes(operstate))
499
156
        struct.pack_into("=LHHLL", data, 0, len(data), msg_type, 0, 0, 0)
500
157
        return data
501
158
502
159
    def test_media_down_up_scenario(self, m_read_netlink_socket,
503
160
                                    m_socket):
504
161
        '''Test for media down up sequence for required interface name'''
505
162
        ifname = "eth0"
506
163
        # construct data for Oper State down
507
164
        data_op_down = self._media_switch_data(ifname, RTM_NEWLINK, OPER_DOWN)
508
165
        # construct data for Oper State up
509
166
        data_op_up = self._media_switch_data(ifname, RTM_NEWLINK, OPER_UP)
510
167
        m_read_netlink_socket.side_effect = [data_op_down, data_op_up]
511
168
        wait_for_media_disconnect_connect(m_socket, ifname)
512
169
        self.assertEqual(m_read_netlink_socket.call_count, 2)
513
170
514
171
    def test_wait_for_media_switch_diff_interface(self, m_read_netlink_socket,
515
172
                                                  m_socket):
516
173
        '''wait_for_media_disconnect_connect ignores unexpected interfaces.
517
174
518
175
        The first two messages are for other interfaces and last two are for
519
176
        expected interface. So the function exit only after receiving last
520
177
        2 messages and therefore the call count for m_read_netlink_socket
521
178
        has to be 4
522
179
        '''
523
180
        other_ifname = "eth1"
524
181
        expected_ifname = "eth0"
525
182
        data_op_down_eth1 = self._media_switch_data(
526
183
                                other_ifname, RTM_NEWLINK, OPER_DOWN)
527
184
        data_op_up_eth1 = self._media_switch_data(
528
185
                                other_ifname, RTM_NEWLINK, OPER_UP)
529
186
        data_op_down_eth0 = self._media_switch_data(
530
187
                                expected_ifname, RTM_NEWLINK, OPER_DOWN)
531
188
        data_op_up_eth0 = self._media_switch_data(
532
189
                                expected_ifname, RTM_NEWLINK, OPER_UP)
533
190
        m_read_netlink_socket.side_effect = [data_op_down_eth1,
534
191
                                             data_op_up_eth1,
535
192
                                             data_op_down_eth0,
536
193
                                             data_op_up_eth0]
537
194
        wait_for_media_disconnect_connect(m_socket, expected_ifname)
538
195
        self.assertIn('Ignored netlink event on interface %s' % other_ifname,
539
196
                      self.logs.getvalue())
540
197
        self.assertEqual(m_read_netlink_socket.call_count, 4)
541
198
542
199
    def test_invalid_msgtype_getlink(self, m_read_netlink_socket, m_socket):
543
200
        '''wait_for_media_disconnect_connect ignores GETLINK events.
544
201
545
202
        The first two messages are for oper down and up for RTM_GETLINK type
546
203
        which netlink module will ignore. The last 2 messages are RTM_NEWLINK
547
204
        with oper state down and up messages. Therefore the call count for
548
205
        m_read_netlink_socket has to be 4 ignoring first 2 messages
549
206
        of RTM_GETLINK
550
207
        '''
551
208
        ifname = "eth0"
552
209
        data_getlink_down = self._media_switch_data(
553
210
                                    ifname, RTM_GETLINK, OPER_DOWN)
554
211
        data_getlink_up = self._media_switch_data(
555
212
                                    ifname, RTM_GETLINK, OPER_UP)
556
213
        data_newlink_down = self._media_switch_data(
557
214
                                    ifname, RTM_NEWLINK, OPER_DOWN)
558
215
        data_newlink_up = self._media_switch_data(
559
216
                                    ifname, RTM_NEWLINK, OPER_UP)
560
217
        m_read_netlink_socket.side_effect = [data_getlink_down,
561
218
                                             data_getlink_up,
562
219
                                             data_newlink_down,
563
220
                                             data_newlink_up]
564
221
        wait_for_media_disconnect_connect(m_socket, ifname)
565
222
        self.assertEqual(m_read_netlink_socket.call_count, 4)
566
223
567
224
    def test_invalid_msgtype_setlink(self, m_read_netlink_socket, m_socket):
568
225
        '''wait_for_media_disconnect_connect ignores SETLINK events.
569
226
570
227
        The first two messages are for oper down and up for RTM_GETLINK type
571
228
        which it will ignore. 3rd and 4th messages are RTM_NEWLINK with down
572
229
        and up messages. This function should exit after 4th messages since it
573
230
        sees down->up scenario. So the call count for m_read_netlink_socket
574
231
        has to be 4 ignoring first 2 messages of RTM_GETLINK and
575
232
        last 2 messages of RTM_NEWLINK
576
233
        '''
577
234
        ifname = "eth0"
578
235
        data_setlink_down = self._media_switch_data(
579
236
                                    ifname, RTM_SETLINK, OPER_DOWN)
580
237
        data_setlink_up = self._media_switch_data(
581
238
                                    ifname, RTM_SETLINK, OPER_UP)
582
239
        data_newlink_down = self._media_switch_data(
583
240
                                    ifname, RTM_NEWLINK, OPER_DOWN)
584
241
        data_newlink_up = self._media_switch_data(
585
242
                                    ifname, RTM_NEWLINK, OPER_UP)
586
243
        m_read_netlink_socket.side_effect = [data_setlink_down,
587
244
                                             data_setlink_up,
588
245
                                             data_newlink_down,
589
246
                                             data_newlink_up,
590
247
                                             data_newlink_down,
591
248
                                             data_newlink_up]
592
249
        wait_for_media_disconnect_connect(m_socket, ifname)
593
250
        self.assertEqual(m_read_netlink_socket.call_count, 4)
594
251
595
252
    def test_netlink_invalid_switch_scenario(self, m_read_netlink_socket,
596
253
                                             m_socket):
597
254
        '''returns only if it receives UP event after a DOWN event'''
598
255
        ifname = "eth0"
599
256
        data_op_down = self._media_switch_data(ifname, RTM_NEWLINK, OPER_DOWN)
600
257
        data_op_up = self._media_switch_data(ifname, RTM_NEWLINK, OPER_UP)
601
258
        data_op_dormant = self._media_switch_data(ifname, RTM_NEWLINK,
602
259
                                                  OPER_DORMANT)
603
260
        data_op_notpresent = self._media_switch_data(ifname, RTM_NEWLINK,
604
261
                                                     OPER_NOTPRESENT)
605
262
        data_op_lowerdown = self._media_switch_data(ifname, RTM_NEWLINK,
606
263
                                                    OPER_LOWERLAYERDOWN)
607
264
        data_op_testing = self._media_switch_data(ifname, RTM_NEWLINK,
608
265
                                                  OPER_TESTING)
609
266
        data_op_unknown = self._media_switch_data(ifname, RTM_NEWLINK,
610
267
                                                  OPER_UNKNOWN)
611
268
        m_read_netlink_socket.side_effect = [data_op_up, data_op_up,
612
269
                                             data_op_dormant, data_op_up,
613
270
                                             data_op_notpresent, data_op_up,
614
271
                                             data_op_lowerdown, data_op_up,
615
272
                                             data_op_testing, data_op_up,
616
273
                                             data_op_unknown, data_op_up,
617
274
                                             data_op_down, data_op_up]
618
275
        wait_for_media_disconnect_connect(m_socket, ifname)
619
276
        self.assertEqual(m_read_netlink_socket.call_count, 14)
620
277
621
278
    def test_netlink_valid_inbetween_transitions(self, m_read_netlink_socket,
622
279
                                                 m_socket):
623
280
        '''wait_for_media_disconnect_connect handles in between transitions'''
624
281
        ifname = "eth0"
625
282
        data_op_down = self._media_switch_data(ifname, RTM_NEWLINK, OPER_DOWN)
626
283
        data_op_up = self._media_switch_data(ifname, RTM_NEWLINK, OPER_UP)
627
284
        data_op_dormant = self._media_switch_data(ifname, RTM_NEWLINK,
628
285
                                                  OPER_DORMANT)
629
286
        data_op_unknown = self._media_switch_data(ifname, RTM_NEWLINK,
630
287
                                                  OPER_UNKNOWN)
631
288
        m_read_netlink_socket.side_effect = [data_op_down, data_op_dormant,
632
289
                                             data_op_unknown, data_op_up]
633
290
        wait_for_media_disconnect_connect(m_socket, ifname)
634
291
        self.assertEqual(m_read_netlink_socket.call_count, 4)
635
292
636
293
    def test_netlink_invalid_operstate(self, m_read_netlink_socket, m_socket):
637
294
        '''wait_for_media_disconnect_connect should handle invalid operstates.
638
295
639
296
        The function should not fail and return even if it receives invalid
640
297
        operstates. It always should wait for down up sequence.
641
298
        '''
642
299
        ifname = "eth0"
643
300
        data_op_down = self._media_switch_data(ifname, RTM_NEWLINK, OPER_DOWN)
644
301
        data_op_up = self._media_switch_data(ifname, RTM_NEWLINK, OPER_UP)
645
302
        data_op_invalid = self._media_switch_data(ifname, RTM_NEWLINK, 7)
646
303
        m_read_netlink_socket.side_effect = [data_op_invalid, data_op_up,
647
304
                                             data_op_down, data_op_invalid,
648
305
                                             data_op_up]
649
306
        wait_for_media_disconnect_connect(m_socket, ifname)
650
307
        self.assertEqual(m_read_netlink_socket.call_count, 5)
651
308
652
309
    def test_wait_invalid_socket(self, m_read_netlink_socket, m_socket):
653
310
        '''wait_for_media_disconnect_connect handle none netlink socket.'''
654
311
        socket = None
655
312
        ifname = "eth0"
656
313
        with self.assertRaises(AssertionError) as context:
657
314
            wait_for_media_disconnect_connect(socket, ifname)
658
315
        self.assertTrue('netlink socket is none' in str(context.exception))
659
316
660
317
    def test_wait_invalid_ifname(self, m_read_netlink_socket, m_socket):
661
318
        '''wait_for_media_disconnect_connect handle none interface name'''
662
319
        ifname = None
663
320
        with self.assertRaises(AssertionError) as context:
664
321
            wait_for_media_disconnect_connect(m_socket, ifname)
665
322
        self.assertTrue('interface name is none' in str(context.exception))
666
323
        ifname = ""
667
324
        with self.assertRaises(AssertionError) as context:
668
325
            wait_for_media_disconnect_connect(m_socket, ifname)
669
326
        self.assertTrue('interface name cannot be empty' in
670
327
                        str(context.exception))
671
328
672
329
    def test_wait_invalid_rta_attr(self, m_read_netlink_socket, m_socket):
673
330
        ''' wait_for_media_disconnect_connect handles invalid rta data'''
674
331
        ifname = "eth0"
675
332
        data_invalid1 = self._media_switch_data(None, RTM_NEWLINK, OPER_DOWN)
676
333
        data_invalid2 = self._media_switch_data(ifname, RTM_NEWLINK, None)
677
334
        data_op_down = self._media_switch_data(ifname, RTM_NEWLINK, OPER_DOWN)
678
335
        data_op_up = self._media_switch_data(ifname, RTM_NEWLINK, OPER_UP)
679
336
        m_read_netlink_socket.side_effect = [data_invalid1, data_invalid2,
680
337
                                             data_op_down, data_op_up]
681
338
        wait_for_media_disconnect_connect(m_socket, ifname)
682
339
        self.assertEqual(m_read_netlink_socket.call_count, 4)
683
340
684
341
    def test_read_multiple_netlink_msgs(self, m_read_netlink_socket, m_socket):
685
342
        '''Read multiple messages in single receive call'''
686
343
        ifname = "eth0"
687
344
        bytes = ifname.encode("utf-8")
688
345
        data = bytearray(96)
689
346
        struct.pack_into("=LHHLL", data, 0, 48, RTM_NEWLINK, 0, 0, 0)
690
347
        struct.pack_into("HH4sHHc", data, RTATTR_START_OFFSET, 8, 3,
691
348
                         bytes, 5, 16, int_to_bytes(OPER_DOWN))
692
349
        struct.pack_into("=LHHLL", data, 48, 48, RTM_NEWLINK, 0, 0, 0)
693
350
        struct.pack_into("HH4sHHc", data, 48 + RTATTR_START_OFFSET, 8,
694
351
                         3, bytes, 5, 16, int_to_bytes(OPER_UP))
695
352
        m_read_netlink_socket.return_value = data
696
353
        wait_for_media_disconnect_connect(m_socket, ifname)
697
354
        self.assertEqual(m_read_netlink_socket.call_count, 1)
698
355
699
356
    def test_read_partial_netlink_msgs(self, m_read_netlink_socket, m_socket):
700
357
        '''Read partial messages in receive call'''
701
358
        ifname = "eth0"
702
359
        bytes = ifname.encode("utf-8")
703
360
        data1 = bytearray(112)
704
361
        data2 = bytearray(32)
705
362
        struct.pack_into("=LHHLL", data1, 0, 48, RTM_NEWLINK, 0, 0, 0)
706
363
        struct.pack_into("HH4sHHc", data1, RTATTR_START_OFFSET, 8, 3,
707
364
                         bytes, 5, 16, int_to_bytes(OPER_DOWN))
708
365
        struct.pack_into("=LHHLL", data1, 48, 48, RTM_NEWLINK, 0, 0, 0)
709
366
        struct.pack_into("HH4sHHc", data1, 80, 8, 3, bytes, 5, 16,
710
367
                         int_to_bytes(OPER_DOWN))
711
368
        struct.pack_into("=LHHLL", data1, 96, 48, RTM_NEWLINK, 0, 0, 0)
712
369
        struct.pack_into("HH4sHHc", data2, 16, 8, 3, bytes, 5, 16,
713
370
                         int_to_bytes(OPER_UP))
714
371
        m_read_netlink_socket.side_effect = [data1, data2]
715
372
        wait_for_media_disconnect_connect(m_socket, ifname)
716
373
        self.assertEqual(m_read_netlink_socket.call_count, 2)
717
diff --git a/tests/unittests/test_datasource/test_azure.py b/tests/unittests/test_datasource/test_azure.py
718
index 5ea7ae5..417d86a 100644
719
--- a/tests/unittests/test_datasource/test_azure.py
720
+++ b/tests/unittests/test_datasource/test_azure.py
721
@@ -564,6 +564,8 @@ fdescfs            /dev/fd          fdescfs rw              0 0
722
564
        self.assertEqual(1, report_ready_func.call_count)
564
        self.assertEqual(1, report_ready_func.call_count)
723
565
565
724
566
    @mock.patch('cloudinit.sources.DataSourceAzure.util.write_file')
566
    @mock.patch('cloudinit.sources.DataSourceAzure.util.write_file')
725
567
    @mock.patch('cloudinit.sources.helpers.netlink.'
726
568
                'wait_for_media_disconnect_connect')
727
567
    @mock.patch(
569
    @mock.patch(
728
568
        'cloudinit.sources.DataSourceAzure.DataSourceAzure._report_ready')
570
        'cloudinit.sources.DataSourceAzure.DataSourceAzure._report_ready')
729
569
    @mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
571
    @mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
730
@@ -572,7 +574,7 @@ fdescfs            /dev/fd          fdescfs rw              0 0
731
572
    def test_crawl_metadata_on_reprovision_reports_ready_using_lease(
574
    def test_crawl_metadata_on_reprovision_reports_ready_using_lease(
732
573
                            self, m_readurl, m_dhcp,
575
                            self, m_readurl, m_dhcp,
733
574
                            m_net, report_ready_func,
576
                            m_net, report_ready_func,
735
575
                            m_write):
577
                            m_media_switch, m_write):
736
576
        """If reprovisioning, report ready using the obtained lease"""
578
        """If reprovisioning, report ready using the obtained lease"""
737
577
        ovfenv = construct_valid_ovf_env(
579
        ovfenv = construct_valid_ovf_env(
738
578
                            platform_settings={"PreprovisionedVm": "True"})
580
                            platform_settings={"PreprovisionedVm": "True"})
739
@@ -586,6 +588,7 @@ fdescfs            /dev/fd          fdescfs rw              0 0
740
586
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
588
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
741
587
            'unknown-245': '624c3620'}
589
            'unknown-245': '624c3620'}
742
588
        m_dhcp.return_value = [lease]
590
        m_dhcp.return_value = [lease]
743
591
        m_media_switch.return_value = None
744
589
592
745
590
        reprovision_ovfenv = construct_valid_ovf_env()
593
        reprovision_ovfenv = construct_valid_ovf_env()
746
591
        m_readurl.return_value = url_helper.StringResponse(
594
        m_readurl.return_value = url_helper.StringResponse(
747
@@ -1676,6 +1679,8 @@ class TestPreprovisioningShouldReprovision(CiTestCase):
748
1676
1679
749
1677
@mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
1680
@mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
750
1678
@mock.patch('cloudinit.net.dhcp.maybe_perform_dhcp_discovery')
1681
@mock.patch('cloudinit.net.dhcp.maybe_perform_dhcp_discovery')
751
1682
@mock.patch('cloudinit.sources.helpers.netlink.'
752
1683
            'wait_for_media_disconnect_connect')
753
1679
@mock.patch('requests.Session.request')
1684
@mock.patch('requests.Session.request')
754
1680
@mock.patch(MOCKPATH + 'DataSourceAzure._report_ready')
1685
@mock.patch(MOCKPATH + 'DataSourceAzure._report_ready')
755
1681
class TestPreprovisioningPollIMDS(CiTestCase):
1686
class TestPreprovisioningPollIMDS(CiTestCase):
756
@@ -1689,7 +1694,8 @@ class TestPreprovisioningPollIMDS(CiTestCase):
757
1689
1694
758
1690
    @mock.patch(MOCKPATH + 'EphemeralDHCPv4')
1695
    @mock.patch(MOCKPATH + 'EphemeralDHCPv4')
759
1691
    def test_poll_imds_re_dhcp_on_timeout(self, m_dhcpv4, report_ready_func,
1696
    def test_poll_imds_re_dhcp_on_timeout(self, m_dhcpv4, report_ready_func,
761
1692
                                          fake_resp, m_dhcp, m_net):
1697
                                          fake_resp, m_media_switch, m_dhcp,
762
1698
                                          m_net):
763
1693
        """The poll_imds will retry DHCP on IMDS timeout."""
1699
        """The poll_imds will retry DHCP on IMDS timeout."""
764
1694
        report_file = self.tmp_path('report_marker', self.tmp)
1700
        report_file = self.tmp_path('report_marker', self.tmp)
765
1695
        lease = {
1701
        lease = {
766
@@ -1697,7 +1703,7 @@ class TestPreprovisioningPollIMDS(CiTestCase):
767
1697
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
1703
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
768
1698
            'unknown-245': '624c3620'}
1704
            'unknown-245': '624c3620'}
769
1699
        m_dhcp.return_value = [lease]
1705
        m_dhcp.return_value = [lease]
771
1700
1706
        m_media_switch.return_value = None
772
1701
        dhcp_ctx = mock.MagicMock(lease=lease)
1707
        dhcp_ctx = mock.MagicMock(lease=lease)
773
1702
        dhcp_ctx.obtain_lease.return_value = lease
1708
        dhcp_ctx.obtain_lease.return_value = lease
774
1703
        m_dhcpv4.return_value = dhcp_ctx
1709
        m_dhcpv4.return_value = dhcp_ctx
775
@@ -1723,11 +1729,12 @@ class TestPreprovisioningPollIMDS(CiTestCase):
776
1723
            dsa._poll_imds()
1729
            dsa._poll_imds()
777
1724
        self.assertEqual(report_ready_func.call_count, 1)
1730
        self.assertEqual(report_ready_func.call_count, 1)
778
1725
        report_ready_func.assert_called_with(lease=lease)
1731
        report_ready_func.assert_called_with(lease=lease)
780
1726
        self.assertEqual(2, m_dhcpv4.call_count, 'Expected 2 DHCP calls')
1732
        self.assertEqual(3, m_dhcpv4.call_count, 'Expected 3 DHCP calls')
781
1727
        self.assertEqual(3, self.tries, 'Expected 3 total reads from IMDS')
1733
        self.assertEqual(3, self.tries, 'Expected 3 total reads from IMDS')
782
1728
1734
785
1729
    def test_poll_imds_report_ready_false(self, report_ready_func,
1735
    def test_poll_imds_report_ready_false(self,
786
1730
                                          fake_resp, m_dhcp, m_net):
1736
                                          report_ready_func, fake_resp,
787
1737
                                          m_media_switch, m_dhcp, m_net):
788
1731
        """The poll_imds should not call reporting ready
1738
        """The poll_imds should not call reporting ready
789
1732
           when flag is false"""
1739
           when flag is false"""
790
1733
        report_file = self.tmp_path('report_marker', self.tmp)
1740
        report_file = self.tmp_path('report_marker', self.tmp)
791
@@ -1736,6 +1743,7 @@ class TestPreprovisioningPollIMDS(CiTestCase):
792
1736
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
1743
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
793
1737
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
1744
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
794
1738
            'unknown-245': '624c3620'}]
1745
            'unknown-245': '624c3620'}]
795
1746
        m_media_switch.return_value = None
796
1739
        dsa = dsaz.DataSourceAzure({}, distro=None, paths=self.paths)
1747
        dsa = dsaz.DataSourceAzure({}, distro=None, paths=self.paths)
797
1740
        with mock.patch(MOCKPATH + 'REPORTED_READY_MARKER_FILE', report_file):
1748
        with mock.patch(MOCKPATH + 'REPORTED_READY_MARKER_FILE', report_file):
798
1741
            dsa._poll_imds()
1749
            dsa._poll_imds()
799
@@ -1745,6 +1753,8 @@ class TestPreprovisioningPollIMDS(CiTestCase):
800
1745
@mock.patch(MOCKPATH + 'util.subp')
1753
@mock.patch(MOCKPATH + 'util.subp')
801
1746
@mock.patch(MOCKPATH + 'util.write_file')
1754
@mock.patch(MOCKPATH + 'util.write_file')
802
1747
@mock.patch(MOCKPATH + 'util.is_FreeBSD')
1755
@mock.patch(MOCKPATH + 'util.is_FreeBSD')
803
1756
@mock.patch('cloudinit.sources.helpers.netlink.'
804
1757
            'wait_for_media_disconnect_connect')
805
1748
@mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
1758
@mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
806
1749
@mock.patch('cloudinit.net.dhcp.maybe_perform_dhcp_discovery')
1759
@mock.patch('cloudinit.net.dhcp.maybe_perform_dhcp_discovery')
807
1750
@mock.patch('requests.Session.request')
1760
@mock.patch('requests.Session.request')
808
@@ -1757,10 +1767,13 @@ class TestAzureDataSourcePreprovisioning(CiTestCase):
809
1757
        self.paths = helpers.Paths({'cloud_dir': tmp})
1767
        self.paths = helpers.Paths({'cloud_dir': tmp})
810
1758
        dsaz.BUILTIN_DS_CONFIG['data_dir'] = self.waagent_d
1768
        dsaz.BUILTIN_DS_CONFIG['data_dir'] = self.waagent_d
811
1759
1769
813
1760
    def test_poll_imds_returns_ovf_env(self, fake_resp, m_dhcp, m_net,
1770
    def test_poll_imds_returns_ovf_env(self, fake_resp,
814
1771
                                       m_dhcp, m_net,
815
1772
                                       m_media_switch,
816
1761
                                       m_is_bsd, write_f, subp):
1773
                                       m_is_bsd, write_f, subp):
817
1762
        """The _poll_imds method should return the ovf_env.xml."""
1774
        """The _poll_imds method should return the ovf_env.xml."""
818
1763
        m_is_bsd.return_value = False
1775
        m_is_bsd.return_value = False
819
1776
        m_media_switch.return_value = None
820
1764
        m_dhcp.return_value = [{
1777
        m_dhcp.return_value = [{
821
1765
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
1778
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
822
1766
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0'}]
1779
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0'}]
823
@@ -1778,16 +1791,19 @@ class TestAzureDataSourcePreprovisioning(CiTestCase):
824
1778
                                             'Cloud-Init/%s' % vs()
1791
                                             'Cloud-Init/%s' % vs()
825
1779
                                             }, method='GET', timeout=1,
1792
                                             }, method='GET', timeout=1,
826
1780
                                    url=full_url)])
1793
                                    url=full_url)])
828
1781
        self.assertEqual(m_dhcp.call_count, 1)
1794
        self.assertEqual(m_dhcp.call_count, 2)
829
1782
        m_net.assert_any_call(
1795
        m_net.assert_any_call(
830
1783
            broadcast='192.168.2.255', interface='eth9', ip='192.168.2.9',
1796
            broadcast='192.168.2.255', interface='eth9', ip='192.168.2.9',
831
1784
            prefix_or_mask='255.255.255.0', router='192.168.2.1')
1797
            prefix_or_mask='255.255.255.0', router='192.168.2.1')
833
1785
        self.assertEqual(m_net.call_count, 1)
1798
        self.assertEqual(m_net.call_count, 2)
834
1786
1799
836
1787
    def test__reprovision_calls__poll_imds(self, fake_resp, m_dhcp, m_net,
1800
    def test__reprovision_calls__poll_imds(self, fake_resp,
837
1801
                                           m_dhcp, m_net,
838
1802
                                           m_media_switch,
839
1788
                                           m_is_bsd, write_f, subp):
1803
                                           m_is_bsd, write_f, subp):
840
1789
        """The _reprovision method should call poll IMDS."""
1804
        """The _reprovision method should call poll IMDS."""
841
1790
        m_is_bsd.return_value = False
1805
        m_is_bsd.return_value = False
842
1806
        m_media_switch.return_value = None
843
1791
        m_dhcp.return_value = [{
1807
        m_dhcp.return_value = [{
844
1792
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
1808
            'interface': 'eth9', 'fixed-address': '192.168.2.9',
845
1793
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
1809
            'routers': '192.168.2.1', 'subnet-mask': '255.255.255.0',
846
@@ -1811,11 +1827,11 @@ class TestAzureDataSourcePreprovisioning(CiTestCase):
847
1811
                                             'User-Agent':
1827
                                             'User-Agent':
848
1812
                                             'Cloud-Init/%s' % vs()},
1828
                                             'Cloud-Init/%s' % vs()},
849
1813
                                    method='GET', timeout=1, url=full_url)])
1829
                                    method='GET', timeout=1, url=full_url)])
851
1814
        self.assertEqual(m_dhcp.call_count, 1)
1830
        self.assertEqual(m_dhcp.call_count, 2)
852
1815
        m_net.assert_any_call(
1831
        m_net.assert_any_call(
853
1816
            broadcast='192.168.2.255', interface='eth9', ip='192.168.2.9',
1832
            broadcast='192.168.2.255', interface='eth9', ip='192.168.2.9',
854
1817
            prefix_or_mask='255.255.255.0', router='192.168.2.1')
1833
            prefix_or_mask='255.255.255.0', router='192.168.2.1')
856
1818
        self.assertEqual(m_net.call_count, 1)
1834
        self.assertEqual(m_net.call_count, 2)
857
1819
1835
858
1820
1836
859
1821
class TestRemoveUbuntuNetworkConfigScripts(CiTestCase):
1837
class TestRemoveUbuntuNetworkConfigScripts(CiTestCase):
Status:	Merged
Approved by:	Ryan Harper on 2018-11-29
Approved revision:	56559c2548f858046a0775d21190cb167463cdcb
Merge reported by:	Server Team CI bot
Merged at revision:	not available
Proposed branch:	~tamilmani1989/cloud-init:azure_networking
Merge into:	cloud-init:master
Diff against target:	859 lines (+678/-16) 4 files modified cloudinit/sources/DataSourceAzure.py (+27/-4) cloudinit/sources/helpers/netlink.py (+250/-0) cloudinit/sources/helpers/tests/test_netlink.py (+373/-0) tests/unittests/test_datasource/test_azure.py (+28/-12)
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Server Team CI bot	continuous-integration		Approve on 2018-11-29
Scott Moser			Approve on 2018-11-28
Sushant Sharma (community)		2018-01-20	Approve on 2018-11-28
Ryan Harper			Approve on 2018-11-28
Chad Smith			Approve on 2018-11-20
Paul Meyer (community)			Needs Fixing on 2018-11-02
Douglas Jordan		2018-03-20	Pending
Review via email: mp+336392@code.launchpad.net