1
diff --git a/cloudinit/sources/DataSourceScaleway.py b/cloudinit/sources/DataSourceScaleway.py
2
0
new file mode 100644
0
new file mode 100644
3
index 0000000..93b4be9
4
--- /dev/null
5
+++ b/cloudinit/sources/DataSourceScaleway.py
6
@@ -0,0 +1,223 @@
7
1
# Author: Julien Castets <castets.j@gmail.com>
8
2
#
9
3
# This file is part of cloud-init. See LICENSE file for license information.
10
4
11
5
# Scaleway API:
12
6
# https://developer.scaleway.com/#metadata
13
7
14
8
import json
15
9
import os
16
10
import socket
17
11
import time
18
12
19
13
import requests
20
14
21
15
# pylint fails to import the two modules below.
22
16
# pylint: disable=E0401
23
17
from requests.packages.urllib3.connection import HTTPConnection
24
18
from requests.packages.urllib3.poolmanager import PoolManager
25
19
26
20
from cloudinit import log as logging
27
21
from cloudinit import sources
28
22
from cloudinit import url_helper
29
23
from cloudinit import util
30
24
31
25
32
26
LOG = logging.getLogger(__name__)
33
27
34
28
DS_BASE_URL = 'http://169.254.42.42'
35
29
36
30
BUILTIN_DS_CONFIG = {
37
31
    'metadata_url': DS_BASE_URL + '/conf?format=json',
38
32
    'userdata_url': DS_BASE_URL + '/user_data/cloud-init',
39
33
    'vendordata_url': DS_BASE_URL + '/vendor_data/cloud-init'
40
34
}
41
35
42
36
DEF_MD_RETRIES = 5
43
37
DEF_MD_TIMEOUT = 10
44
38
45
39
46
40
def on_scaleway():
47
41
    """
48
42
    There are three ways to detect if you are on Scaleway:
49
43
50
44
    * check DMI data: not yet implemented by Scaleway, but the check is made to
51
45
      be future-proof.
52
46
    * the initrd created the file /var/run/scaleway.
53
47
    * "scaleway" is in the kernel cmdline.
54
48
    """
55
49
    vendor_name = util.read_dmi_data('system-manufacturer')
56
50
    if vendor_name == 'Scaleway':
57
51
        return True
58
52
59
53
    if os.path.exists('/var/run/scaleway'):
60
54
        return True
61
55
62
56
    cmdline = util.get_cmdline()
63
57
    if 'scaleway' in cmdline:
64
58
        return True
65
59
66
60
    return False
67
61
68
62
69
63
class SourceAddressAdapter(requests.adapters.HTTPAdapter):
70
64
    """
71
65
    Adapter for requests to choose the local address to bind to.
72
66
    """
73
67
    def __init__(self, source_address, **kwargs):
74
68
        self.source_address = source_address
75
69
        super(SourceAddressAdapter, self).__init__(**kwargs)
76
70
77
71
    def init_poolmanager(self, connections, maxsize, block=False):
78
72
        socket_options = HTTPConnection.default_socket_options + [
79
73
            (socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
80
74
        ]
81
75
        self.poolmanager = PoolManager(num_pools=connections,
82
76
                                       maxsize=maxsize,
83
77
                                       block=block,
84
78
                                       source_address=self.source_address,
85
79
                                       socket_options=socket_options)
86
80
87
81
88
82
def query_data_api_once(api_address, timeout, requests_session):
89
83
    """
90
84
    Retrieve user data or vendor data.
91
85
92
86
    Scaleway user/vendor data API returns HTTP/404 if user/vendor data is not
93
87
    set.
94
88
95
89
    This function calls `url_helper.readurl` but instead of considering
96
90
    HTTP/404 as an error that requires a retry, it considers it as empty
97
91
    user/vendor data.
98
92
99
93
    Also, be aware the user data/vendor API requires the source port to be
100
94
    below 1024 to ensure the client is root (since non-root users can't bind
101
95
    ports below 1024). If requests raises ConnectionError (EADDRINUSE), the
102
96
    caller should retry to call this function on an other port.
103
97
    """
104
98
    try:
105
99
        resp = url_helper.readurl(
106
100
            api_address,
107
101
            data=None,
108
102
            timeout=timeout,
109
103
            # It's the caller's responsability to recall this function in case
110
104
            # of exception. Don't let url_helper.readurl() retry by itself.
111
105
            retries=0,
112
106
            session=requests_session,
113
107
            # If the error is a HTTP/404 or a ConnectionError, go into raise
114
108
            # block below.
115
109
            exception_cb=lambda _, exc: exc.code == 404 or (
116
110
                isinstance(exc.cause, requests.exceptions.ConnectionError)
117
111
            )
118
112
        )
119
113
        return util.decode_binary(resp.contents)
120
114
    except url_helper.UrlError as exc:
121
115
        # Empty user data.
122
116
        if exc.code == 404:
123
117
            return None
124
118
        raise
125
119
126
120
127
121
def query_data_api(api_type, api_address, retries, timeout):
128
122
    """
129
123
    Get user or vendor data.
130
124
131
125
    Handle the retrying logic in case the source port is used.
132
126
    """
133
127
    # Query user/vendor data. Try to make a request on the first privileged
134
128
    # port available.
135
129
    for port in range(1, max(retries, 2)):
136
130
        try:
137
131
            LOG.debug(
138
132
                'Trying to get %s data (bind on port %d)...',
139
133
                api_type, port
140
134
            )
141
135
            requests_session = requests.Session()
142
136
            requests_session.mount(
143
137
                'http://',
144
138
                SourceAddressAdapter(source_address=('0.0.0.0', port))
145
139
            )
146
140
            data = query_data_api_once(
147
141
                api_address,
148
142
                timeout=timeout,
149
143
                requests_session=requests_session
150
144
            )
151
145
            LOG.debug('%s-data downloaded', api_type)
152
146
            return data
153
147
154
148
        except url_helper.UrlError as exc:
155
149
            # Local port already in use or HTTP/429.
156
150
            LOG.warning('Error while trying to get %s data: %s', api_type, exc)
157
151
            time.sleep(5)
158
152
            last_exc = exc
159
153
            continue
160
154
161
155
    # Max number of retries reached.
162
156
    raise last_exc
163
157
164
158
165
159
class DataSourceScaleway(sources.DataSource):
166
160
167
161
    def __init__(self, sys_cfg, distro, paths):
168
162
        super(DataSourceScaleway, self).__init__(sys_cfg, distro, paths)
169
163
170
164
        self.ds_cfg = util.mergemanydict([
171
165
            util.get_cfg_by_path(sys_cfg, ["datasource", "Scaleway"], {}),
172
166
            BUILTIN_DS_CONFIG
173
167
        ])
174
168
175
169
        self.metadata_address = self.ds_cfg['metadata_url']
176
170
        self.userdata_address = self.ds_cfg['userdata_url']
177
171
        self.vendordata_address = self.ds_cfg['vendordata_url']
178
172
179
173
        self.retries = int(self.ds_cfg.get('retries', DEF_MD_RETRIES))
180
174
        self.timeout = int(self.ds_cfg.get('timeout', DEF_MD_TIMEOUT))
181
175
182
176
    def get_data(self):
183
177
        if not on_scaleway():
184
178
            return False
185
179
186
180
        resp = url_helper.readurl(self.metadata_address,
187
181
                                  timeout=self.timeout,
188
182
                                  retries=self.retries)
189
183
        self.metadata = json.loads(util.decode_binary(resp.contents))
190
184
191
185
        self.userdata_raw = query_data_api(
192
186
            'user-data', self.userdata_address,
193
187
            self.retries, self.timeout
194
188
        )
195
189
        self.vendordata_raw = query_data_api(
196
190
            'vendor-data', self.vendordata_address,
197
191
            self.retries, self.timeout
198
192
        )
199
193
        return True
200
194
201
195
    @property
202
196
    def launch_index(self):
203
197
        return None
204
198
205
199
    def get_instance_id(self):
206
200
        return self.metadata['id']
207
201
208
202
    def get_public_ssh_keys(self):
209
203
        return [key['key'] for key in self.metadata['ssh_public_keys']]
210
204
211
205
    def get_hostname(self, fqdn=False, resolve_ip=False):
212
206
        return self.metadata['hostname']
213
207
214
208
    @property
215
209
    def availability_zone(self):
216
210
        return None
217
211
218
212
    @property
219
213
    def region(self):
220
214
        return None
221
215
222
216
223
217
datasources = [
224
218
    (DataSourceScaleway, (sources.DEP_FILESYSTEM, sources.DEP_NETWORK)),
225
219
]
226
220
227
221
228
222
def get_datasource_list(depends):
229
223
    return sources.list_from_depends(depends, datasources)
230
diff --git a/cloudinit/url_helper.py b/cloudinit/url_helper.py
231
index d2b92e6..7cf76aa 100644
232
--- a/cloudinit/url_helper.py
233
+++ b/cloudinit/url_helper.py
234
@@ -172,7 +172,8 @@ def _get_ssl_args(url, ssl_details):
235
172
172
236
173
def readurl(url, data=None, timeout=None, retries=0, sec_between=1,
173
def readurl(url, data=None, timeout=None, retries=0, sec_between=1,
237
174
            headers=None, headers_cb=None, ssl_details=None,
174
            headers=None, headers_cb=None, ssl_details=None,
239
175
            check_status=True, allow_redirects=True, exception_cb=None):
175
            check_status=True, allow_redirects=True, exception_cb=None,
240
176
            session=None):
241
176
    url = _cleanurl(url)
177
    url = _cleanurl(url)
242
177
    req_args = {
178
    req_args = {
243
178
        'url': url,
179
        'url': url,
244
@@ -231,7 +232,12 @@ def readurl(url, data=None, timeout=None, retries=0, sec_between=1,
245
231
            LOG.debug("[%s/%s] open '%s' with %s configuration", i,
232
            LOG.debug("[%s/%s] open '%s' with %s configuration", i,
246
232
                      manual_tries, url, filtered_req_args)
233
                      manual_tries, url, filtered_req_args)
247
233
234
249
234
            r = requests.request(**req_args)
235
            if session is None:
250
236
                session = requests.Session()
251
237
252
238
            with session as sess:
253
239
                r = sess.request(**req_args)
254
240
255
235
            if check_status:
241
            if check_status:
256
236
                r.raise_for_status()
242
                r.raise_for_status()
257
237
            LOG.debug("Read from %s (%s, %sb) after %s attempts", url,
243
            LOG.debug("Read from %s (%s, %sb) after %s attempts", url,
258
diff --git a/tests/unittests/test_datasource/test_scaleway.py b/tests/unittests/test_datasource/test_scaleway.py
259
238
new file mode 100644
244
new file mode 100644
260
index 0000000..65d83ad
261
--- /dev/null
262
+++ b/tests/unittests/test_datasource/test_scaleway.py
263
@@ -0,0 +1,262 @@
264
1
# This file is part of cloud-init. See LICENSE file for license information.
265
2
266
3
import json
267
4
268
5
import httpretty
269
6
import requests
270
7
271
8
from cloudinit import helpers
272
9
from cloudinit import settings
273
10
from cloudinit.sources import DataSourceScaleway
274
11
275
12
from ..helpers import mock, HttprettyTestCase, TestCase
276
13
277
14
278
15
class DataResponses(object):
279
16
    """
280
17
    Possible responses of the API endpoint
281
18
    169.254.42.42/user_data/cloud-init and
282
19
    169.254.42.42/vendor_data/cloud-init.
283
20
    """
284
21
285
22
    FAKE_USER_DATA = '#!/bin/bash\necho "user-data"'
286
23
287
24
    @staticmethod
288
25
    def rate_limited(method, uri, headers):
289
26
        return 429, headers, ''
290
27
291
28
    @staticmethod
292
29
    def api_error(method, uri, headers):
293
30
        return 500, headers, ''
294
31
295
32
    @classmethod
296
33
    def get_ok(cls, method, uri, headers):
297
34
        return 200, headers, cls.FAKE_USER_DATA
298
35
299
36
    @staticmethod
300
37
    def empty(method, uri, headers):
301
38
        """
302
39
        No user data for this server.
303
40
        """
304
41
        return 404, headers, ''
305
42
306
43
307
44
class MetadataResponses(object):
308
45
    """
309
46
    Possible responses of the metadata API.
310
47
    """
311
48
312
49
    FAKE_METADATA = {
313
50
        'id': '00000000-0000-0000-0000-000000000000',
314
51
        'hostname': 'scaleway.host',
315
52
        'ssh_public_keys': [{
316
53
            'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
317
54
            'fingerprint': '2048 06:ae:...  login (RSA)'
318
55
        }, {
319
56
            'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
320
57
            'fingerprint': '2048 06:ff:...  login2 (RSA)'
321
58
        }]
322
59
    }
323
60
324
61
    @classmethod
325
62
    def get_ok(cls, method, uri, headers):
326
63
        return 200, headers, json.dumps(cls.FAKE_METADATA)
327
64
328
65
329
66
class TestOnScaleway(TestCase):
330
67
331
68
    def install_mocks(self, fake_dmi, fake_file_exists, fake_cmdline):
332
69
        mock, faked = fake_dmi
333
70
        mock.return_value = 'Scaleway' if faked else 'Whatever'
334
71
335
72
        mock, faked = fake_file_exists
336
73
        mock.return_value = faked
337
74
338
75
        mock, faked = fake_cmdline
339
76
        mock.return_value = \
340
77
            'initrd=initrd showopts scaleway nousb' if faked \
341
78
            else 'BOOT_IMAGE=/vmlinuz-3.11.0-26-generic'
342
79
343
80
    @mock.patch('cloudinit.util.get_cmdline')
344
81
    @mock.patch('os.path.exists')
345
82
    @mock.patch('cloudinit.util.read_dmi_data')
346
83
    def test_not_on_scaleway(self, m_read_dmi_data, m_file_exists,
347
84
                             m_get_cmdline):
348
85
        self.install_mocks(
349
86
            fake_dmi=(m_read_dmi_data, False),
350
87
            fake_file_exists=(m_file_exists, False),
351
88
            fake_cmdline=(m_get_cmdline, False)
352
89
        )
353
90
        self.assertFalse(DataSourceScaleway.on_scaleway())
354
91
355
92
        # When not on Scaleway, get_data() returns False.
356
93
        datasource = DataSourceScaleway.DataSourceScaleway(
357
94
            settings.CFG_BUILTIN, None, helpers.Paths({})
358
95
        )
359
96
        self.assertFalse(datasource.get_data())
360
97
361
98
    @mock.patch('cloudinit.util.get_cmdline')
362
99
    @mock.patch('os.path.exists')
363
100
    @mock.patch('cloudinit.util.read_dmi_data')
364
101
    def test_on_scaleway_dmi(self, m_read_dmi_data, m_file_exists,
365
102
                             m_get_cmdline):
366
103
        """
367
104
        dmidecode returns "Scaleway".
368
105
        """
369
106
        # dmidecode returns "Scaleway"
370
107
        self.install_mocks(
371
108
            fake_dmi=(m_read_dmi_data, True),
372
109
            fake_file_exists=(m_file_exists, False),
373
110
            fake_cmdline=(m_get_cmdline, False)
374
111
        )
375
112
        self.assertTrue(DataSourceScaleway.on_scaleway())
376
113
377
114
    @mock.patch('cloudinit.util.get_cmdline')
378
115
    @mock.patch('os.path.exists')
379
116
    @mock.patch('cloudinit.util.read_dmi_data')
380
117
    def test_on_scaleway_var_run_scaleway(self, m_read_dmi_data, m_file_exists,
381
118
                                          m_get_cmdline):
382
119
        """
383
120
        /var/run/scaleway exists.
384
121
        """
385
122
        self.install_mocks(
386
123
            fake_dmi=(m_read_dmi_data, False),
387
124
            fake_file_exists=(m_file_exists, True),
388
125
            fake_cmdline=(m_get_cmdline, False)
389
126
        )
390
127
        self.assertTrue(DataSourceScaleway.on_scaleway())
391
128
392
129
    @mock.patch('cloudinit.util.get_cmdline')
393
130
    @mock.patch('os.path.exists')
394
131
    @mock.patch('cloudinit.util.read_dmi_data')
395
132
    def test_on_scaleway_cmdline(self, m_read_dmi_data, m_file_exists,
396
133
                                 m_get_cmdline):
397
134
        """
398
135
        "scaleway" in /proc/cmdline.
399
136
        """
400
137
        self.install_mocks(
401
138
            fake_dmi=(m_read_dmi_data, False),
402
139
            fake_file_exists=(m_file_exists, False),
403
140
            fake_cmdline=(m_get_cmdline, True)
404
141
        )
405
142
        self.assertTrue(DataSourceScaleway.on_scaleway())
406
143
407
144
408
145
def get_source_address_adapter(*args, **kwargs):
409
146
    """
410
147
    Scaleway user/vendor data API requires to be called with a privileged port.
411
148
412
149
    If the unittests are run as non-root, the user doesn't have the permission
413
150
    to bind on ports below 1024.
414
151
415
152
    This function removes the bind on a privileged address, since anyway the
416
153
    HTTP call is mocked by httpretty.
417
154
    """
418
155
    kwargs.pop('source_address')
419
156
    return requests.adapters.HTTPAdapter(*args, **kwargs)
420
157
421
158
422
159
class TestDataSourceScaleway(HttprettyTestCase):
423
160
424
161
    def setUp(self):
425
162
        self.datasource = DataSourceScaleway.DataSourceScaleway(
426
163
            settings.CFG_BUILTIN, None, helpers.Paths({})
427
164
        )
428
165
        super(TestDataSourceScaleway, self).setUp()
429
166
430
167
        self.metadata_url = \
431
168
            DataSourceScaleway.BUILTIN_DS_CONFIG['metadata_url']
432
169
        self.userdata_url = \
433
170
            DataSourceScaleway.BUILTIN_DS_CONFIG['userdata_url']
434
171
        self.vendordata_url = \
435
172
            DataSourceScaleway.BUILTIN_DS_CONFIG['vendordata_url']
436
173
437
174
    @httpretty.activate
438
175
    @mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
439
176
                get_source_address_adapter)
440
177
    @mock.patch('cloudinit.util.get_cmdline')
441
178
    @mock.patch('time.sleep', return_value=None)
442
179
    def test_metadata_ok(self, sleep, m_get_cmdline):
443
180
        """
444
181
        get_data() returns metadata, user data and vendor data.
445
182
        """
446
183
        m_get_cmdline.return_value = 'scaleway'
447
184
448
185
        # Make user data API return a valid response
449
186
        httpretty.register_uri(httpretty.GET, self.metadata_url,
450
187
                               body=MetadataResponses.get_ok)
451
188
        httpretty.register_uri(httpretty.GET, self.userdata_url,
452
189
                               body=DataResponses.get_ok)
453
190
        httpretty.register_uri(httpretty.GET, self.vendordata_url,
454
191
                               body=DataResponses.get_ok)
455
192
        self.datasource.get_data()
456
193
457
194
        self.assertEqual(self.datasource.get_instance_id(),
458
195
                         MetadataResponses.FAKE_METADATA['id'])
459
196
        self.assertEqual(self.datasource.get_public_ssh_keys(), [
460
197
            elem['key'] for elem in
461
198
            MetadataResponses.FAKE_METADATA['ssh_public_keys']
462
199
        ])
463
200
        self.assertEqual(self.datasource.get_hostname(),
464
201
                         MetadataResponses.FAKE_METADATA['hostname'])
465
202
        self.assertEqual(self.datasource.get_userdata_raw(),
466
203
                         DataResponses.FAKE_USER_DATA)
467
204
        self.assertEqual(self.datasource.get_vendordata_raw(),
468
205
                         DataResponses.FAKE_USER_DATA)
469
206
        self.assertIsNone(self.datasource.availability_zone)
470
207
        self.assertIsNone(self.datasource.region)
471
208
        self.assertEqual(sleep.call_count, 0)
472
209
473
210
    @httpretty.activate
474
211
    @mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
475
212
                get_source_address_adapter)
476
213
    @mock.patch('cloudinit.util.get_cmdline')
477
214
    @mock.patch('time.sleep', return_value=None)
478
215
    def test_metadata_404(self, sleep, m_get_cmdline):
479
216
        """
480
217
        get_data() returns metadata, but no user data nor vendor data.
481
218
        """
482
219
        m_get_cmdline.return_value = 'scaleway'
483
220
484
221
        # Make user and vendor data APIs return HTTP/404, which means there is
485
222
        # no user / vendor data for the server.
486
223
        httpretty.register_uri(httpretty.GET, self.metadata_url,
487
224
                               body=MetadataResponses.get_ok)
488
225
        httpretty.register_uri(httpretty.GET, self.userdata_url,
489
226
                               body=DataResponses.empty)
490
227
        httpretty.register_uri(httpretty.GET, self.vendordata_url,
491
228
                               body=DataResponses.empty)
492
229
        self.datasource.get_data()
493
230
        self.assertIsNone(self.datasource.get_userdata_raw())
494
231
        self.assertIsNone(self.datasource.get_vendordata_raw())
495
232
        self.assertEqual(sleep.call_count, 0)
496
233
497
234
    @httpretty.activate
498
235
    @mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
499
236
                get_source_address_adapter)
500
237
    @mock.patch('cloudinit.util.get_cmdline')
501
238
    @mock.patch('time.sleep', return_value=None)
502
239
    def test_metadata_rate_limit(self, sleep, m_get_cmdline):
503
240
        """
504
241
        get_data() is rate limited two times by the metadata API when fetching
505
242
        user data.
506
243
        """
507
244
        m_get_cmdline.return_value = 'scaleway'
508
245
509
246
        httpretty.register_uri(httpretty.GET, self.metadata_url,
510
247
                               body=MetadataResponses.get_ok)
511
248
        httpretty.register_uri(httpretty.GET, self.vendordata_url,
512
249
                               body=DataResponses.empty)
513
250
514
251
        httpretty.register_uri(
515
252
            httpretty.GET, self.userdata_url,
516
253
            responses=[
517
254
                httpretty.Response(body=DataResponses.rate_limited),
518
255
                httpretty.Response(body=DataResponses.rate_limited),
519
256
                httpretty.Response(body=DataResponses.get_ok),
520
257
            ]
521
258
        )
522
259
        self.datasource.get_data()
523
260
        self.assertEqual(self.datasource.get_userdata_raw(),
524
261
                         DataResponses.FAKE_USER_DATA)
525
262
        self.assertEqual(sleep.call_count, 2)
526
diff --git a/tools/ds-identify b/tools/ds-identify
527
index 7c8b144..33bd299 100755
528
--- a/tools/ds-identify
529
+++ b/tools/ds-identify
530
@@ -112,7 +112,7 @@ DI_DSNAME=""
531
112
# be searched if there is no setting found in config.
112
# be searched if there is no setting found in config.
532
113
DI_DSLIST_DEFAULT="MAAS ConfigDrive NoCloud AltCloud Azure Bigstep \
113
DI_DSLIST_DEFAULT="MAAS ConfigDrive NoCloud AltCloud Azure Bigstep \
533
114
CloudSigma CloudStack DigitalOcean AliYun Ec2 GCE OpenNebula OpenStack \
114
CloudSigma CloudStack DigitalOcean AliYun Ec2 GCE OpenNebula OpenStack \
535
115
OVF SmartOS"
115
OVF SmartOS Scaleway"
536
116
DI_DSLIST=""
116
DI_DSLIST=""
537
117
DI_MODE=""
117
DI_MODE=""
538
118
DI_ON_FOUND=""
118
DI_ON_FOUND=""
539
@@ -896,6 +896,22 @@ dscheck_None() {
540
896
    return ${DS_NOT_FOUND}
896
    return ${DS_NOT_FOUND}
541
897
}
897
}
542
898
898
543
899
dscheck_Scaleway() {
544
900
    if [ "${DI_DMI_SYS_VENDOR}" = "Scaleway" ]; then
545
901
        return $DS_FOUND
546
902
    fi
547
903
548
904
    case " ${DI_KERNEL_CMDLINE} " in
549
905
        *\ scaleway\ *) return ${DS_FOUND};;
550
906
    esac
551
907
552
908
    if [ -f ${PATH_ROOT}/var/run/scaleway ]; then
553
909
        return ${DS_FOUND}
554
910
    fi
555
911
556
912
    return ${DS_NOT_FOUND}
557
913
}
558
914
559
899
collect_info() {
915
collect_info() {
560
900
    read_virt
916
    read_virt
561
901
    read_pid1_product_name
917
    read_pid1_product_name
Status:	Merged
Approved by:	Scott Moser on 2017-07-17
Approved revision:	f61323fb96a58688be73566eaa30c8f7c3b3adc6
Merged at revision:	e80517ae6aea49c9ab3bd622a33fee44014f485f
Proposed branch:	~jcastets/cloud-init:scaleway-datasource
Merge into:	cloud-init:master
Diff against target:	561 lines (+510/-3) 4 files modified cloudinit/sources/DataSourceScaleway.py (+223/-0) cloudinit/url_helper.py (+8/-2) tests/unittests/test_datasource/test_scaleway.py (+262/-0) tools/ds-identify (+17/-1)
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Chad Smith			Approve on 2017-07-17
Scott Moser		2017-06-15	Approve on 2017-07-17
Server Team CI bot	continuous-integration		Approve on 2017-07-17
Review via email: mp+325740@code.launchpad.net