# This file is part of cloud-init. See LICENSE file for license information.
import json
import httpretty
import requests
from cloudinit import helpers
from cloudinit import settings
from cloudinit import sources
from cloudinit.sources import DataSourceScaleway
from cloudinit.tests.helpers import mock, HttprettyTestCase, CiTestCase
class DataResponses(object):
"""
Possible responses of the API endpoint
169.254.42.42/user_data/cloud-init and
169.254.42.42/vendor_data/cloud-init.
"""
FAKE_USER_DATA = '#!/bin/bash\necho "user-data"'
@staticmethod
def rate_limited(method, uri, headers):
return 429, headers, ''
@staticmethod
def api_error(method, uri, headers):
return 500, headers, ''
@classmethod
def get_ok(cls, method, uri, headers):
return 200, headers, cls.FAKE_USER_DATA
@staticmethod
def empty(method, uri, headers):
"""
No user data for this server.
"""
return 404, headers, ''
class MetadataResponses(object):
"""
Possible responses of the metadata API.
"""
FAKE_METADATA = {
'id': '00000000-0000-0000-0000-000000000000',
'hostname': 'scaleway.host',
'tags': [
"AUTHORIZED_KEY=ssh-rsa_AAAAB3NzaC1yc2EAAAADAQABDDDDD",
],
'ssh_public_keys': [{
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
'fingerprint': '2048 06:ae:... login (RSA)'
}, {
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
'fingerprint': '2048 06:ff:... login2 (RSA)'
}]
}
@classmethod
def get_ok(cls, method, uri, headers):
return 200, headers, json.dumps(cls.FAKE_METADATA)
class TestOnScaleway(CiTestCase):
def setUp(self):
super(TestOnScaleway, self).setUp()
self.tmp = self.tmp_dir()
def install_mocks(self, fake_dmi, fake_file_exists, fake_cmdline):
mock, faked = fake_dmi
mock.return_value = 'Scaleway' if faked else 'Whatever'
mock, faked = fake_file_exists
mock.return_value = faked
mock, faked = fake_cmdline
mock.return_value = \
'initrd=initrd showopts scaleway nousb' if faked \
else 'BOOT_IMAGE=/vmlinuz-3.11.0-26-generic'
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('os.path.exists')
@mock.patch('cloudinit.util.read_dmi_data')
def test_not_on_scaleway(self, m_read_dmi_data, m_file_exists,
m_get_cmdline):
self.install_mocks(
fake_dmi=(m_read_dmi_data, False),
fake_file_exists=(m_file_exists, False),
fake_cmdline=(m_get_cmdline, False)
)
self.assertFalse(DataSourceScaleway.on_scaleway())
# When not on Scaleway, get_data() returns False.
datasource = DataSourceScaleway.DataSourceScaleway(
settings.CFG_BUILTIN, None, helpers.Paths({'run_dir': self.tmp})
)
self.assertFalse(datasource.get_data())
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('os.path.exists')
@mock.patch('cloudinit.util.read_dmi_data')
def test_on_scaleway_dmi(self, m_read_dmi_data, m_file_exists,
m_get_cmdline):
"""
dmidecode returns "Scaleway".
"""
# dmidecode returns "Scaleway"
self.install_mocks(
fake_dmi=(m_read_dmi_data, True),
fake_file_exists=(m_file_exists, False),
fake_cmdline=(m_get_cmdline, False)
)
self.assertTrue(DataSourceScaleway.on_scaleway())
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('os.path.exists')
@mock.patch('cloudinit.util.read_dmi_data')
def test_on_scaleway_var_run_scaleway(self, m_read_dmi_data, m_file_exists,
m_get_cmdline):
"""
/var/run/scaleway exists.
"""
self.install_mocks(
fake_dmi=(m_read_dmi_data, False),
fake_file_exists=(m_file_exists, True),
fake_cmdline=(m_get_cmdline, False)
)
self.assertTrue(DataSourceScaleway.on_scaleway())
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('os.path.exists')
@mock.patch('cloudinit.util.read_dmi_data')
def test_on_scaleway_cmdline(self, m_read_dmi_data, m_file_exists,
m_get_cmdline):
"""
"scaleway" in /proc/cmdline.
"""
self.install_mocks(
fake_dmi=(m_read_dmi_data, False),
fake_file_exists=(m_file_exists, False),
fake_cmdline=(m_get_cmdline, True)
)
self.assertTrue(DataSourceScaleway.on_scaleway())
def get_source_address_adapter(*args, **kwargs):
"""
Scaleway user/vendor data API requires to be called with a privileged port.
If the unittests are run as non-root, the user doesn't have the permission
to bind on ports below 1024.
This function removes the bind on a privileged address, since anyway the
HTTP call is mocked by httpretty.
"""
kwargs.pop('source_address')
return requests.adapters.HTTPAdapter(*args, **kwargs)
class TestDataSourceScaleway(HttprettyTestCase):
def setUp(self):
tmp = self.tmp_dir()
self.datasource = DataSourceScaleway.DataSourceScaleway(
settings.CFG_BUILTIN, None, helpers.Paths({'run_dir': tmp})
)
super(TestDataSourceScaleway, self).setUp()
self.metadata_url = \
DataSourceScaleway.BUILTIN_DS_CONFIG['metadata_url']
self.userdata_url = \
DataSourceScaleway.BUILTIN_DS_CONFIG['userdata_url']
self.vendordata_url = \
DataSourceScaleway.BUILTIN_DS_CONFIG['vendordata_url']
self.add_patch('cloudinit.sources.DataSourceScaleway.on_scaleway',
'_m_on_scaleway', return_value=True)
self.add_patch(
'cloudinit.sources.DataSourceScaleway.net.find_fallback_nic',
'_m_find_fallback_nic', return_value='scalewaynic0')
@mock.patch('cloudinit.sources.DataSourceScaleway.EphemeralDHCPv4')
@mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
get_source_address_adapter)
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('time.sleep', return_value=None)
def test_metadata_ok(self, sleep, m_get_cmdline, dhcpv4):
"""
get_data() returns metadata, user data and vendor data.
"""
m_get_cmdline.return_value = 'scaleway'
# Make user data API return a valid response
httpretty.register_uri(httpretty.GET, self.metadata_url,
body=MetadataResponses.get_ok)
httpretty.register_uri(httpretty.GET, self.userdata_url,
body=DataResponses.get_ok)
httpretty.register_uri(httpretty.GET, self.vendordata_url,
body=DataResponses.get_ok)
self.datasource.get_data()
self.assertEqual(self.datasource.get_instance_id(),
MetadataResponses.FAKE_METADATA['id'])
self.assertEqual(self.datasource.get_public_ssh_keys().sort(), [
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABDDDDD',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
].sort())
self.assertEqual(self.datasource.get_hostname(),
MetadataResponses.FAKE_METADATA['hostname'])
self.assertEqual(self.datasource.get_userdata_raw(),
DataResponses.FAKE_USER_DATA)
self.assertEqual(self.datasource.get_vendordata_raw(),
DataResponses.FAKE_USER_DATA)
self.assertIsNone(self.datasource.availability_zone)
self.assertIsNone(self.datasource.region)
self.assertEqual(sleep.call_count, 0)
def test_ssh_keys_empty(self):
"""
get_public_ssh_keys() should return empty list if no ssh key are
available
"""
self.datasource.metadata['tags'] = []
self.datasource.metadata['ssh_public_keys'] = []
self.assertEqual(self.datasource.get_public_ssh_keys(), [])
def test_ssh_keys_only_tags(self):
"""
get_public_ssh_keys() should return list of keys available in tags
"""
self.datasource.metadata['tags'] = [
"AUTHORIZED_KEY=ssh-rsa_AAAAB3NzaC1yc2EAAAADAQABDDDDD",
"AUTHORIZED_KEY=ssh-rsa_AAAAB3NzaC1yc2EAAAADAQABCCCCC",
]
self.datasource.metadata['ssh_public_keys'] = []
self.assertEqual(self.datasource.get_public_ssh_keys().sort(), [
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABDDDDD',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
].sort())
def test_ssh_keys_only_conf(self):
"""
get_public_ssh_keys() should return list of keys available in
ssh_public_keys field
"""
self.datasource.metadata['tags'] = []
self.datasource.metadata['ssh_public_keys'] = [{
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
'fingerprint': '2048 06:ae:... login (RSA)'
}, {
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
'fingerprint': '2048 06:ff:... login2 (RSA)'
}]
self.assertEqual(self.datasource.get_public_ssh_keys().sort(), [
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABDDDDD',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
].sort())
def test_ssh_keys_both(self):
"""
get_public_ssh_keys() should return a merge of keys available
in ssh_public_keys and tags
"""
self.datasource.metadata['tags'] = [
"AUTHORIZED_KEY=ssh-rsa_AAAAB3NzaC1yc2EAAAADAQABDDDDD",
]
self.datasource.metadata['ssh_public_keys'] = [{
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
'fingerprint': '2048 06:ae:... login (RSA)'
}, {
'key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
'fingerprint': '2048 06:ff:... login2 (RSA)'
}]
self.assertEqual(self.datasource.get_public_ssh_keys().sort(), [
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABCCCCC',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABDDDDD',
u'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABA',
].sort())
@mock.patch('cloudinit.sources.DataSourceScaleway.EphemeralDHCPv4')
@mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
get_source_address_adapter)
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('time.sleep', return_value=None)
def test_metadata_404(self, sleep, m_get_cmdline, dhcpv4):
"""
get_data() returns metadata, but no user data nor vendor data.
"""
m_get_cmdline.return_value = 'scaleway'
# Make user and vendor data APIs return HTTP/404, which means there is
# no user / vendor data for the server.
httpretty.register_uri(httpretty.GET, self.metadata_url,
body=MetadataResponses.get_ok)
httpretty.register_uri(httpretty.GET, self.userdata_url,
body=DataResponses.empty)
httpretty.register_uri(httpretty.GET, self.vendordata_url,
body=DataResponses.empty)
self.datasource.get_data()
self.assertIsNone(self.datasource.get_userdata_raw())
self.assertIsNone(self.datasource.get_vendordata_raw())
self.assertEqual(sleep.call_count, 0)
@mock.patch('cloudinit.sources.DataSourceScaleway.EphemeralDHCPv4')
@mock.patch('cloudinit.sources.DataSourceScaleway.SourceAddressAdapter',
get_source_address_adapter)
@mock.patch('cloudinit.util.get_cmdline')
@mock.patch('time.sleep', return_value=None)
def test_metadata_rate_limit(self, sleep, m_get_cmdline, dhcpv4):
"""
get_data() is rate limited two times by the metadata API when fetching
user data.
"""
m_get_cmdline.return_value = 'scaleway'
httpretty.register_uri(httpretty.GET, self.metadata_url,
body=MetadataResponses.get_ok)
httpretty.register_uri(httpretty.GET, self.vendordata_url,
body=DataResponses.empty)
httpretty.register_uri(
httpretty.GET, self.userdata_url,
responses=[
httpretty.Response(body=DataResponses.rate_limited),
httpretty.Response(body=DataResponses.rate_limited),
httpretty.Response(body=DataResponses.get_ok),
]
)
self.datasource.get_data()
self.assertEqual(self.datasource.get_userdata_raw(),
DataResponses.FAKE_USER_DATA)
self.assertEqual(sleep.call_count, 2)
@mock.patch('cloudinit.sources.DataSourceScaleway.net.find_fallback_nic')
@mock.patch('cloudinit.util.get_cmdline')
def test_network_config_ok(self, m_get_cmdline, fallback_nic):
"""
network_config will only generate IPv4 config if no ipv6 data is
available in the metadata
"""
m_get_cmdline.return_value = 'scaleway'
fallback_nic.return_value = 'ens2'
self.datasource.metadata['ipv6'] = None
netcfg = self.datasource.network_config
resp = {
'version': 1,
'config': [
{
'type': 'physical',
'name': 'ens2',
'subnets': [{'type': 'dhcp4'}]
}
]
}
self.assertEqual(netcfg, resp)
@mock.patch('cloudinit.sources.DataSourceScaleway.net.find_fallback_nic')
@mock.patch('cloudinit.util.get_cmdline')
def test_network_config_ipv6_ok(self, m_get_cmdline, fallback_nic):
"""
network_config will only generate IPv4/v6 configs if ipv6 data is
available in the metadata
"""
m_get_cmdline.return_value = 'scaleway'
fallback_nic.return_value = 'ens2'
self.datasource.metadata['ipv6'] = {
'address': '2000:abc:4444:9876::42:999',
'gateway': '2000:abc:4444:9876::42:000',
'netmask': '127',
}
netcfg = self.datasource.network_config
resp = {
'version': 1,
'config': [
{
'type': 'physical',
'name': 'ens2',
'subnets': [
{
'type': 'dhcp4'
},
{
'type': 'static',
'address': '2000:abc:4444:9876::42:999',
'gateway': '2000:abc:4444:9876::42:000',
'netmask': '127',
}
]
}
]
}
self.assertEqual(netcfg, resp)
@mock.patch('cloudinit.sources.DataSourceScaleway.net.find_fallback_nic')
@mock.patch('cloudinit.util.get_cmdline')
def test_network_config_existing(self, m_get_cmdline, fallback_nic):
"""
network_config() should return the same data if a network config
already exists
"""
m_get_cmdline.return_value = 'scaleway'
self.datasource._network_config = '0xdeadbeef'
netcfg = self.datasource.network_config
self.assertEqual(netcfg, '0xdeadbeef')
@mock.patch('cloudinit.sources.DataSourceScaleway.net.find_fallback_nic')
@mock.patch('cloudinit.util.get_cmdline')
def test_network_config_unset(self, m_get_cmdline, fallback_nic):
"""
_network_config will be set to sources.UNSET after the first boot.
Make sure it behave correctly.
"""
m_get_cmdline.return_value = 'scaleway'
fallback_nic.return_value = 'ens2'
self.datasource.metadata['ipv6'] = None
self.datasource._network_config = sources.UNSET
resp = {
'version': 1,
'config': [
{
'type': 'physical',
'name': 'ens2',
'subnets': [{'type': 'dhcp4'}]
}
]
}
netcfg = self.datasource.network_config
self.assertEqual(netcfg, resp)
@mock.patch('cloudinit.sources.DataSourceScaleway.LOG.warning')
@mock.patch('cloudinit.sources.DataSourceScaleway.net.find_fallback_nic')
@mock.patch('cloudinit.util.get_cmdline')
def test_network_config_cached_none(self, m_get_cmdline, fallback_nic,
logwarning):
"""
network_config() should return config data if cached data is None
rather than sources.UNSET
"""
m_get_cmdline.return_value = 'scaleway'
fallback_nic.return_value = 'ens2'
self.datasource.metadata['ipv6'] = None
self.datasource._network_config = None
resp = {
'version': 1,
'config': [
{
'type': 'physical',
'name': 'ens2',
'subnets': [{'type': 'dhcp4'}]
}
]
}
netcfg = self.datasource.network_config
self.assertEqual(netcfg, resp)
logwarning.assert_called_with('Found None as cached _network_config. '
'Resetting to %s', sources.UNSET)