summaryrefslogtreecommitdiff
path: root/tests/unittests/test_datasource/test_gce.py
blob: 01f4cbd1405162587f45d0cb66dd2a48b70b9ffa (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
# Copyright (C) 2014 Vaidas Jablonskis
#
# Author: Vaidas Jablonskis <jablonskis@gmail.com>
#
# This file is part of cloud-init. See LICENSE file for license information.

import datetime
import httpretty
import json
import re
from unittest import mock
from urllib.parse import urlparse

from base64 import b64encode, b64decode

from cloudinit import distros
from cloudinit import helpers
from cloudinit import settings
from cloudinit.sources import DataSourceGCE

from cloudinit.tests import helpers as test_helpers


GCE_META = {
    'instance/id': '123',
    'instance/zone': 'foo/bar',
    'instance/hostname': 'server.project-foo.local',
}

GCE_META_PARTIAL = {
    'instance/id': '1234',
    'instance/hostname': 'server.project-bar.local',
    'instance/zone': 'bar/baz',
}

GCE_META_ENCODING = {
    'instance/id': '12345',
    'instance/hostname': 'server.project-baz.local',
    'instance/zone': 'baz/bang',
    'instance/attributes': {
        'user-data': b64encode(b'#!/bin/echo baz\n').decode('utf-8'),
        'user-data-encoding': 'base64',
    }
}

GCE_USER_DATA_TEXT = {
    'instance/id': '12345',
    'instance/hostname': 'server.project-baz.local',
    'instance/zone': 'baz/bang',
    'instance/attributes': {
        'user-data': '#!/bin/sh\necho hi mom\ntouch /run/up-now\n',
    }
}

HEADERS = {'Metadata-Flavor': 'Google'}
MD_URL_RE = re.compile(
    r'http://metadata.google.internal/computeMetadata/v1/.*')
GUEST_ATTRIBUTES_URL = ('http://metadata.google.internal/computeMetadata/'
                        'v1/instance/guest-attributes/hostkeys/')


def _set_mock_metadata(gce_meta=None):
    if gce_meta is None:
        gce_meta = GCE_META

    def _request_callback(method, uri, headers):
        url_path = urlparse(uri).path
        if url_path.startswith('/computeMetadata/v1/'):
            path = url_path.split('/computeMetadata/v1/')[1:][0]
            recursive = path.endswith('/')
            path = path.rstrip('/')
        else:
            path = None
        if path in gce_meta:
            response = gce_meta.get(path)
            if recursive:
                response = json.dumps(response)
            return (200, headers, response)
        else:
            return (404, headers, '')

    # reset is needed. https://github.com/gabrielfalcao/HTTPretty/issues/316
    httpretty.register_uri(httpretty.GET, MD_URL_RE, body=_request_callback)


@httpretty.activate
class TestDataSourceGCE(test_helpers.HttprettyTestCase):

    def _make_distro(self, dtype, def_user=None):
        cfg = dict(settings.CFG_BUILTIN)
        cfg['system_info']['distro'] = dtype
        paths = helpers.Paths(cfg['system_info']['paths'])
        distro_cls = distros.fetch(dtype)
        if def_user:
            cfg['system_info']['default_user'] = def_user.copy()
        distro = distro_cls(dtype, cfg['system_info'], paths)
        return distro

    def setUp(self):
        tmp = self.tmp_dir()
        self.ds = DataSourceGCE.DataSourceGCE(
            settings.CFG_BUILTIN, None,
            helpers.Paths({'run_dir': tmp}))
        ppatch = self.m_platform_reports_gce = mock.patch(
            'cloudinit.sources.DataSourceGCE.platform_reports_gce')
        self.m_platform_reports_gce = ppatch.start()
        self.m_platform_reports_gce.return_value = True
        self.addCleanup(ppatch.stop)
        super(TestDataSourceGCE, self).setUp()

    def test_connection(self):
        _set_mock_metadata()
        success = self.ds.get_data()
        self.assertTrue(success)

        req_header = httpretty.last_request().headers
        for header_name, expected_value in HEADERS.items():
            self.assertEqual(expected_value, req_header.get(header_name))

    def test_metadata(self):
        # UnicodeDecodeError if set to ds.userdata instead of userdata_raw
        meta = GCE_META.copy()
        meta['instance/attributes/user-data'] = b'/bin/echo \xff\n'

        _set_mock_metadata()
        self.ds.get_data()

        shostname = GCE_META.get('instance/hostname').split('.')[0]
        self.assertEqual(shostname,
                         self.ds.get_hostname())

        self.assertEqual(GCE_META.get('instance/id'),
                         self.ds.get_instance_id())

        self.assertEqual(GCE_META.get('instance/attributes/user-data'),
                         self.ds.get_userdata_raw())

    # test partial metadata (missing user-data in particular)
    def test_metadata_partial(self):
        _set_mock_metadata(GCE_META_PARTIAL)
        self.ds.get_data()

        self.assertEqual(GCE_META_PARTIAL.get('instance/id'),
                         self.ds.get_instance_id())

        shostname = GCE_META_PARTIAL.get('instance/hostname').split('.')[0]
        self.assertEqual(shostname, self.ds.get_hostname())

    def test_userdata_no_encoding(self):
        """check that user-data is read."""
        _set_mock_metadata(GCE_USER_DATA_TEXT)
        self.ds.get_data()
        self.assertEqual(
            GCE_USER_DATA_TEXT['instance/attributes']['user-data'].encode(),
            self.ds.get_userdata_raw())

    def test_metadata_encoding(self):
        """user-data is base64 encoded if user-data-encoding is 'base64'."""
        _set_mock_metadata(GCE_META_ENCODING)
        self.ds.get_data()

        instance_data = GCE_META_ENCODING.get('instance/attributes')
        decoded = b64decode(instance_data.get('user-data'))
        self.assertEqual(decoded, self.ds.get_userdata_raw())

    def test_missing_required_keys_return_false(self):
        for required_key in ['instance/id', 'instance/zone',
                             'instance/hostname']:
            meta = GCE_META_PARTIAL.copy()
            del meta[required_key]
            _set_mock_metadata(meta)
            self.assertEqual(False, self.ds.get_data())
            httpretty.reset()

    def test_no_ssh_keys_metadata(self):
        _set_mock_metadata()
        self.ds.get_data()
        self.assertEqual([], self.ds.get_public_ssh_keys())

    def test_cloudinit_ssh_keys(self):
        valid_key = 'ssh-rsa VALID {0}'
        invalid_key = 'ssh-rsa INVALID {0}'
        project_attributes = {
            'sshKeys': '\n'.join([
                'cloudinit:{0}'.format(valid_key.format(0)),
                'user:{0}'.format(invalid_key.format(0)),
            ]),
            'ssh-keys': '\n'.join([
                'cloudinit:{0}'.format(valid_key.format(1)),
                'user:{0}'.format(invalid_key.format(1)),
            ]),
        }
        instance_attributes = {
            'ssh-keys': '\n'.join([
                'cloudinit:{0}'.format(valid_key.format(2)),
                'user:{0}'.format(invalid_key.format(2)),
            ]),
            'block-project-ssh-keys': 'False',
        }

        meta = GCE_META.copy()
        meta['project/attributes'] = project_attributes
        meta['instance/attributes'] = instance_attributes

        _set_mock_metadata(meta)
        self.ds.get_data()

        expected = [valid_key.format(key) for key in range(3)]
        self.assertEqual(set(expected), set(self.ds.get_public_ssh_keys()))

    @mock.patch("cloudinit.sources.DataSourceGCE.ug_util")
    def test_default_user_ssh_keys(self, mock_ug_util):
        mock_ug_util.normalize_users_groups.return_value = None, None
        mock_ug_util.extract_default.return_value = 'ubuntu', None
        ubuntu_ds = DataSourceGCE.DataSourceGCE(
            settings.CFG_BUILTIN, self._make_distro('ubuntu'),
            helpers.Paths({'run_dir': self.tmp_dir()}))

        valid_key = 'ssh-rsa VALID {0}'
        invalid_key = 'ssh-rsa INVALID {0}'
        project_attributes = {
            'sshKeys': '\n'.join([
                'ubuntu:{0}'.format(valid_key.format(0)),
                'user:{0}'.format(invalid_key.format(0)),
            ]),
            'ssh-keys': '\n'.join([
                'ubuntu:{0}'.format(valid_key.format(1)),
                'user:{0}'.format(invalid_key.format(1)),
            ]),
        }
        instance_attributes = {
            'ssh-keys': '\n'.join([
                'ubuntu:{0}'.format(valid_key.format(2)),
                'user:{0}'.format(invalid_key.format(2)),
            ]),
            'block-project-ssh-keys': 'False',
        }

        meta = GCE_META.copy()
        meta['project/attributes'] = project_attributes
        meta['instance/attributes'] = instance_attributes

        _set_mock_metadata(meta)
        ubuntu_ds.get_data()

        expected = [valid_key.format(key) for key in range(3)]
        self.assertEqual(set(expected), set(ubuntu_ds.get_public_ssh_keys()))

    def test_instance_ssh_keys_override(self):
        valid_key = 'ssh-rsa VALID {0}'
        invalid_key = 'ssh-rsa INVALID {0}'
        project_attributes = {
            'sshKeys': 'cloudinit:{0}'.format(invalid_key.format(0)),
            'ssh-keys': 'cloudinit:{0}'.format(invalid_key.format(1)),
        }
        instance_attributes = {
            'sshKeys': 'cloudinit:{0}'.format(valid_key.format(0)),
            'ssh-keys': 'cloudinit:{0}'.format(valid_key.format(1)),
            'block-project-ssh-keys': 'False',
        }

        meta = GCE_META.copy()
        meta['project/attributes'] = project_attributes
        meta['instance/attributes'] = instance_attributes

        _set_mock_metadata(meta)
        self.ds.get_data()

        expected = [valid_key.format(key) for key in range(2)]
        self.assertEqual(set(expected), set(self.ds.get_public_ssh_keys()))

    def test_block_project_ssh_keys_override(self):
        valid_key = 'ssh-rsa VALID {0}'
        invalid_key = 'ssh-rsa INVALID {0}'
        project_attributes = {
            'sshKeys': 'cloudinit:{0}'.format(invalid_key.format(0)),
            'ssh-keys': 'cloudinit:{0}'.format(invalid_key.format(1)),
        }
        instance_attributes = {
            'ssh-keys': 'cloudinit:{0}'.format(valid_key.format(0)),
            'block-project-ssh-keys': 'True',
        }

        meta = GCE_META.copy()
        meta['project/attributes'] = project_attributes
        meta['instance/attributes'] = instance_attributes

        _set_mock_metadata(meta)
        self.ds.get_data()

        expected = [valid_key.format(0)]
        self.assertEqual(set(expected), set(self.ds.get_public_ssh_keys()))

    def test_only_last_part_of_zone_used_for_availability_zone(self):
        _set_mock_metadata()
        r = self.ds.get_data()
        self.assertEqual(True, r)
        self.assertEqual('bar', self.ds.availability_zone)

    @mock.patch("cloudinit.sources.DataSourceGCE.GoogleMetadataFetcher")
    def test_get_data_returns_false_if_not_on_gce(self, m_fetcher):
        self.m_platform_reports_gce.return_value = False
        ret = self.ds.get_data()
        self.assertEqual(False, ret)
        m_fetcher.assert_not_called()

    def test_has_expired(self):

        def _get_timestamp(days):
            format_str = '%Y-%m-%dT%H:%M:%S+0000'
            today = datetime.datetime.now()
            timestamp = today + datetime.timedelta(days=days)
            return timestamp.strftime(format_str)

        past = _get_timestamp(-1)
        future = _get_timestamp(1)
        ssh_keys = {
            None: False,
            '': False,
            'Invalid': False,
            'user:ssh-rsa key user@domain.com': False,
            'user:ssh-rsa key google {"expireOn":"%s"}' % past: False,
            'user:ssh-rsa key google-ssh': False,
            'user:ssh-rsa key google-ssh {invalid:json}': False,
            'user:ssh-rsa key google-ssh {"userName":"user"}': False,
            'user:ssh-rsa key google-ssh {"expireOn":"invalid"}': False,
            'user:xyz key google-ssh {"expireOn":"%s"}' % future: False,
            'user:xyz key google-ssh {"expireOn":"%s"}' % past: True,
        }

        for key, expired in ssh_keys.items():
            self.assertEqual(DataSourceGCE._has_expired(key), expired)

    def test_parse_public_keys_non_ascii(self):
        public_key_data = [
            'cloudinit:rsa ssh-ke%s invalid' % chr(165),
            'use%sname:rsa ssh-key' % chr(174),
            'cloudinit:test 1',
            'default:test 2',
            'user:test 3',
        ]
        expected = ['test 1', 'test 2']
        found = DataSourceGCE._parse_public_keys(
            public_key_data, default_user='default')
        self.assertEqual(sorted(found), sorted(expected))

    @mock.patch("cloudinit.url_helper.readurl")
    def test_publish_host_keys(self, m_readurl):
        hostkeys = [('ssh-rsa', 'asdfasdf'),
                    ('ssh-ed25519', 'qwerqwer')]
        readurl_expected_calls = [
            mock.call(check_status=False, data=b'asdfasdf', headers=HEADERS,
                      request_method='PUT',
                      url='%s%s' % (GUEST_ATTRIBUTES_URL, 'ssh-rsa')),
            mock.call(check_status=False, data=b'qwerqwer', headers=HEADERS,
                      request_method='PUT',
                      url='%s%s' % (GUEST_ATTRIBUTES_URL, 'ssh-ed25519')),
        ]
        self.ds.publish_host_keys(hostkeys)
        m_readurl.assert_has_calls(readurl_expected_calls, any_order=True)


# vi: ts=4 expandtab