def test_multiple_files(self): """Multiple leases files on azure with one found return that value.""" self.maxDiff = None populate_dir(self.lease_d, {'1': self.azure_lease, '9': self.lxd_lease}) self.assertEqual({'1': self.azure_parsed, '9': self.lxd_parsed}, networkd_load_leases(self.lease_d))
def test_id_in_os_release(self): """os-release containing ID=ubuntu-core is snappy.""" orcontent = '\n'.join(['ID=ubuntu-core', '']) root_d = self.tmp_dir() helpers.populate_dir(root_d, {'etc/os-release': orcontent}) self.reRoot(root_d) self.assertTrue(util.system_is_snappy())
def test_no_required_and_optional(self): dirdata = {'f1': b'f1c', 'f2': b'f2c'} populate_dir(self.tmp, dirdata) ret = util.pathprefix2dict(self.tmp, required=None, optional=['f1', 'f2']) self.assertEqual(dirdata, ret)
def test_apply_network_config_fallback_freebsd(self): fbsd_distro = self._get_distro('freebsd') # a weak attempt to verify that we don't have an implementation # of _write_network_config or apply_network_config in fbsd now, # which would make this test not actually test the fallback. self.assertRaises( NotImplementedError, fbsd_distro._write_network_config, BASE_NET_CFG) # now run mynetcfg = { 'config': [{"type": "physical", "name": "eth0", "mac_address": "c0:d6:9f:2c:e8:80", "subnets": [{"type": "dhcp"}]}], 'version': 1} rc_conf = '/etc/rc.conf' read_bufs = { rc_conf: 'initial-rc-conf-not-validated', '/etc/resolv.conf': 'initial-resolv-conf-not-validated', } tmpd = self.tmp_dir() populate_dir(tmpd, read_bufs) with self.reRooted(tmpd): with mock.patch("cloudinit.distros.freebsd.util.subp", return_value=('vtnet0', '')): fbsd_distro.apply_network_config(mynetcfg, bring_up=False) results = dir2dict(tmpd) self.assertIn(rc_conf, results) self.assertCfgEquals('ifconfig_vtnet0="DHCP"', results[rc_conf]) self.assertEqual(0o644, get_mode(rc_conf, tmpd))
def test_dev_os_remap(self): populate_dir(self.tmp, CFG_DRIVE_FILES_V2) cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN, None, helpers.Paths({})) found = ds.read_config_drive(self.tmp) cfg_ds.metadata = found['metadata'] name_tests = { 'ami': '/dev/vda1', 'root': '/dev/vda1', 'ephemeral0': '/dev/vda2', 'swap': '/dev/vda3', } for name, dev_name in name_tests.items(): with ExitStack() as mocks: provided_name = dev_name[len('/dev/'):] provided_name = "s" + provided_name[1:] find_mock = mocks.enter_context( mock.patch.object(util, 'find_devs_with', return_value=[provided_name])) # We want os.path.exists() to return False on its first call, # and True on its second call. We use a handy generator as # the mock side effect for this. The mocked function returns # what the side effect returns. def exists_side_effect(): yield False yield True exists_mock = mocks.enter_context( mock.patch.object(os.path, 'exists', side_effect=exists_side_effect())) self.assertEqual(dev_name, cfg_ds.device_name_to_device(name)) find_mock.assert_called_once_with(mock.ANY) self.assertEqual(exists_mock.call_count, 2)
def test_simple_write_freebsd_from_v2eni(self): fbsd_distro = self._get_distro('freebsd') rc_conf = '/etc/rc.conf' read_bufs = { rc_conf: 'initial-rc-conf-not-validated', '/etc/resolv.conf': 'initial-resolv-conf-not-validated', } tmpd = self.tmp_dir() populate_dir(tmpd, read_bufs) with self.reRooted(tmpd): with mock.patch("cloudinit.distros.freebsd.util.subp", return_value=('vtnet0', '')): fbsd_distro.apply_network(BASE_NET_CFG_FROM_V2, False) results = dir2dict(tmpd) self.assertIn(rc_conf, results) self.assertCfgEquals( dedent('''\ ifconfig_vtnet0="192.168.1.5 netmask 255.255.255.0" ifconfig_vtnet1="DHCP" defaultrouter="192.168.1.254" '''), results[rc_conf]) self.assertEqual(0o644, get_mode(rc_conf, tmpd))
def test_option_245_not_found_returns_None(self): """A valid lease, but no option 245 should return None.""" populate_dir( self.lease_d, {'9': self.azure_lease.replace("OPTION_245", "OPTION_999")}) self.assertIsNone( wa_shim._networkd_get_value_from_leases(self.lease_d))
def test_handler_full_setup(self): """Test that the handler ends up calling the renderers""" cfg = self._get_base_config_repos() cfg['zypper']['config'] = { 'download.deltarpm': 'False', } root_d = self.tmp_dir() os.makedirs('%s/etc/zypp/repos.d' % root_d) helpers.populate_dir(root_d, {self.zypp_conf: '# Zypp config\n'}) self.reRoot(root_d) cc_zypper_add_repo.handle('zypper_add_repo', cfg, None, LOG, []) cfg_out = os.path.join(root_d, self.zypp_conf) contents = util.load_file(cfg_out) expected = [ '# Zypp config', '# Added via cloud.cfg', 'download.deltarpm=False', ] for item in contents.split('\n'): if item not in expected: self.assertIsNone(item) repos = glob.glob('%s/etc/zypp/repos.d/*.repo' % root_d) expected_repos = ['testing-foo.repo', 'testing-bar.repo'] if len(repos) != 2: assert 'Number of repos written is "%d" expected 2' % len(repos) for repo in repos: repo_name = os.path.basename(repo) if repo_name not in expected_repos: assert 'Found repo with name "%s"; unexpected' % repo_name
def test_metadata_network_interfaces(self, m_is_lxd): gateway = "103.225.10.1" md = { 'instance-id': 'i-abcd', 'local-hostname': 'hostname1', 'network-interfaces': textwrap.dedent("""\ auto eth0 iface eth0 inet static hwaddr 00:16:3e:70:e1:04 address 103.225.10.12 netmask 255.255.255.0 gateway """ + gateway + """ dns-servers 8.8.8.8""")} populate_dir( os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': b"ud", 'meta-data': yaml.dump(md) + "\n"}) sys_cfg = {'datasource': {'NoCloud': {'fs_label': None}}} dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertTrue(ret) # very simple check just for the strings above self.assertIn(gateway, str(dsrc.network_config))
def test_metadata_network_config_over_interfaces(self, m_is_lxd): # network-config should override meta-data/network-interfaces gateway = "103.225.10.1" md = { 'instance-id': 'i-abcd', 'local-hostname': 'hostname1', 'network-interfaces': textwrap.dedent("""\ auto eth0 iface eth0 inet static hwaddr 00:16:3e:70:e1:04 address 103.225.10.12 netmask 255.255.255.0 gateway """ + gateway + """ dns-servers 8.8.8.8""")} netconf = {'version': 1, 'config': [{'type': 'physical', 'name': 'interface0', 'subnets': [{'type': 'dhcp'}]}]} populate_dir( os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': b"ud", 'meta-data': yaml.dump(md) + "\n", 'network-config': yaml.dump(netconf) + "\n"}) sys_cfg = {'datasource': {'NoCloud': {'fs_label': None}}} dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertTrue(ret) self.assertEqual(netconf, dsrc.network_config) self.assertNotIn(gateway, str(dsrc.network_config))
def test_dev_ec2_remap(self): populate_dir(self.tmp, CFG_DRIVE_FILES_V2) cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN, None, helpers.Paths({})) found = ds.read_config_drive(self.tmp) ec2_md = found['ec2-metadata'] os_md = found['metadata'] cfg_ds.ec2_metadata = ec2_md cfg_ds.metadata = os_md name_tests = { 'ami': '/dev/vda1', 'root': '/dev/vda1', 'ephemeral0': '/dev/vda2', 'swap': '/dev/vda3', None: None, 'bob': None, 'root2k': None, } for name, dev_name in name_tests.items(): # We want os.path.exists() to return False on its first call, # and True on its second call. We use a handy generator as # the mock side effect for this. The mocked function returns # what the side effect returns. def exists_side_effect(): yield False yield True with mock.patch.object(os.path, 'exists', side_effect=exists_side_effect()): self.assertEqual(dev_name, cfg_ds.device_name_to_device(name))
def test_dev_os_map(self): populate_dir(self.tmp, CFG_DRIVE_FILES_V2) cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN, None, helpers.Paths({})) found = ds.read_config_drive(self.tmp) os_md = found['metadata'] cfg_ds.metadata = os_md name_tests = { 'ami': '/dev/vda1', 'root': '/dev/vda1', 'ephemeral0': '/dev/vda2', 'swap': '/dev/vda3', } for name, dev_name in name_tests.items(): with ExitStack() as mocks: find_mock = mocks.enter_context( mock.patch.object(util, 'find_devs_with', return_value=[dev_name])) exists_mock = mocks.enter_context( mock.patch.object(os.path, 'exists', return_value=True)) self.assertEqual(dev_name, cfg_ds.device_name_to_device(name)) find_mock.assert_called_once_with(mock.ANY) exists_mock.assert_called_once_with(mock.ANY)
def test_bad_content_in_os_release_no_effect(self, m_cmdline): """malformed os-release should not raise exception.""" m_cmdline.return_value = 'root=/dev/sda' orcontent = '\n'.join(['IDubuntu-core', '']) root_d = self.tmp_dir() helpers.populate_dir(root_d, {'etc/os-release': orcontent}) self.reRoot() self.assertFalse(util.system_is_snappy())
def test_system_image_config_dir_is_snappy(self, m_cmdline): """Existence of /etc/system-image/config.d indicates snappy.""" m_cmdline.return_value = 'root=/dev/sda' root_d = self.tmp_dir() helpers.populate_dir( root_d, {'etc/system-image/config.d/my.file': "_unused"}) self.reRoot(root_d) self.assertTrue(util.system_is_snappy())
def test_unicode_not_messed_up(self): ud = b"userdatablob" helpers.populate_dir( self.tmp, {'meta-data': "key1: val1", 'user-data': ud}) sdir = self.tmp + os.path.sep (found_md, found_ud) = util.read_seeded(sdir) self.assertEqual(found_md, {'key1': 'val1'}) self.assertEqual(found_ud, ud)
def test_channel_ini_with_snappy_is_snappy(self, m_cmdline): """A Channel.ini file with 'ubuntu-core' indicates snappy.""" m_cmdline.return_value = 'root=/dev/sda' root_d = self.tmp_dir() content = '\n'.join(["[Foo]", "source = 'ubuntu-core'", ""]) helpers.populate_dir( root_d, {'etc/system-image/channel.ini': content}) self.reRoot(root_d) self.assertTrue(util.system_is_snappy())
def test_get_data_broken_contextdisk(self): orig_find_devs_with = util.find_devs_with try: # dont' try to lookup for CDs util.find_devs_with = lambda n: [] populate_dir(self.seed_dir, {'context.sh': INVALID_CONTEXT}) dsrc = self.ds(sys_cfg=self.sys_cfg, distro=None, paths=self.paths) self.assertRaises(ds.BrokenContextDiskDir, dsrc.get_data) finally: util.find_devs_with = orig_find_devs_with
def test_nocloud_no_vendordata(self, m_is_lxd): populate_dir(os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': b"ud", 'meta-data': "instance-id: IID\n"}) sys_cfg = {'datasource': {'NoCloud': {'fs_label': None}}} dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertEqual(dsrc.userdata_raw, b"ud") self.assertFalse(dsrc.vendordata) self.assertTrue(ret)
def test_no_config_section_no_new_data(self): """When there is no config section no new data should be written to zypp.conf""" cfg = self._get_base_config_repos() root_d = self.tmp_dir() helpers.populate_dir(root_d, {self.zypp_conf: '# No data'}) self.reRoot(root_d) cc_zypper_add_repo._write_zypp_config(cfg.get('config', {})) cfg_out = os.path.join(root_d, self.zypp_conf) contents = util.load_file(cfg_out) self.assertEqual(contents, '# No data')
def test_seed_dir_bad_json_metadata(self): """Verify that bad json in metadata raises BrokenConfigDriveDir.""" data = copy(CFG_DRIVE_FILES_V2) data["openstack/2012-08-10/meta_data.json"] = "non-json garbage {}" data["openstack/2015-10-15/meta_data.json"] = "non-json garbage {}" data["openstack/latest/meta_data.json"] = "non-json garbage {}" populate_dir(self.tmp, data) self.assertRaises(openstack.BrokenMetadata, ds.read_config_drive, self.tmp)
def test_multiple_returns_first(self): """Somewhat arbitrarily return the first address when multiple. Most important at the moment is that this is consistent behavior rather than changing randomly as in order of a dictionary.""" myval = "624c3601" populate_dir( self.lease_d, {'9': self.azure_lease, '2': self.azure_lease.replace("624c3620", myval)}) self.assertEqual( myval, wa_shim._networkd_get_value_from_leases(self.lease_d))
def cfg_ds_from_dir(base_d, files=None): run = os.path.join(base_d, "run") os.mkdir(run) cfg_ds = ds.DataSourceConfigDrive( settings.CFG_BUILTIN, None, helpers.Paths({'run_dir': run})) cfg_ds.seed_dir = os.path.join(base_d, "seed") if files: populate_dir(cfg_ds.seed_dir, files) cfg_ds.known_macs = KNOWN_MACS.copy() if not cfg_ds.get_data(): raise RuntimeError("Data source did not extract itself from" " seed directory %s" % cfg_ds.seed_dir) return cfg_ds
def test_empty_config_value_no_new_data(self): """When the config section is not empty but there are no values no new data should be written to zypp.conf""" cfg = self._get_base_config_repos() cfg['zypper']['config'] = { 'download.deltarpm': None } root_d = self.tmp_dir() helpers.populate_dir(root_d, {self.zypp_conf: '# No data'}) self.reRoot(root_d) cc_zypper_add_repo._write_zypp_config(cfg.get('config', {})) cfg_out = os.path.join(root_d, self.zypp_conf) contents = util.load_file(cfg_out) self.assertEqual(contents, '# No data')
def test_metadata_network_config_with_toplevel_network(self, m_is_lxd): """network-config may have 'network' top level key.""" netconf = {'config': 'disabled'} populate_dir( os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': b"ud", 'meta-data': "instance-id: IID\n", 'network-config': yaml.dump({'network': netconf}) + "\n"}) sys_cfg = {'datasource': {'NoCloud': {'fs_label': None}}} dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertTrue(ret) self.assertEqual(netconf, dsrc.network_config)
def test_dir_valid(self): """Verify a dir is read as such.""" populate_dir(self.tmp, CFG_DRIVE_FILES_V2) found = ds.read_config_drive(self.tmp) expected_md = copy(OSTACK_META) expected_md['instance-id'] = expected_md['uuid'] expected_md['local-hostname'] = expected_md['hostname'] self.assertEqual(USER_DATA, found['userdata']) self.assertEqual(expected_md, found['metadata']) self.assertEqual(NETWORK_DATA, found['networkdata']) self.assertEqual(found['files']['/etc/foo.cfg'], CONTENT_0) self.assertEqual(found['files']['/etc/bar/bar.cfg'], CONTENT_1)
def test_seed_dir_valid_extra(self): """Verify extra files do not affect datasource validity.""" data = copy(CFG_DRIVE_FILES_V2) data["myfoofile.txt"] = "myfoocontent" data["openstack/latest/random-file.txt"] = "random-content" populate_dir(self.tmp, data) found = ds.read_config_drive(self.tmp) expected_md = copy(OSTACK_META) expected_md['instance-id'] = expected_md['uuid'] expected_md['local-hostname'] = expected_md['hostname'] self.assertEqual(expected_md, found['metadata'])
def test_nocloud_seed_dir_non_lxd_platform_is_nocloud(self, m_is_lxd): """Non-lxd environments will list nocloud as the platform.""" m_is_lxd.return_value = False md = {'instance-id': 'IID', 'dsmode': 'local'} seed_dir = os.path.join(self.paths.seed_dir, "nocloud") populate_dir(seed_dir, {'user-data': '', 'meta-data': yaml.safe_dump(md)}) sys_cfg = { 'datasource': {'NoCloud': {'fs_label': None}} } dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) self.assertTrue(dsrc.get_data()) self.assertEqual(dsrc.platform_type, 'nocloud') self.assertEqual( dsrc.subplatform, 'seed-dir (%s)' % seed_dir)
def test_metadata_network_config(self, m_is_lxd): # network-config needs to get into network_config netconf = {'version': 1, 'config': [{'type': 'physical', 'name': 'interface0', 'subnets': [{'type': 'dhcp'}]}]} populate_dir( os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': b"ud", 'meta-data': "instance-id: IID\n", 'network-config': yaml.dump(netconf) + "\n"}) sys_cfg = {'datasource': {'NoCloud': {'fs_label': None}}} dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertTrue(ret) self.assertEqual(netconf, dsrc.network_config)
def test_nocloud_seed_dir_on_lxd(self, m_is_lxd): md = {'instance-id': 'IID', 'dsmode': 'local'} ud = b"USER_DATA_HERE" seed_dir = os.path.join(self.paths.seed_dir, "nocloud") populate_dir(seed_dir, {'user-data': ud, 'meta-data': yaml.safe_dump(md)}) sys_cfg = { 'datasource': {'NoCloud': {'fs_label': None}} } dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertEqual(dsrc.userdata_raw, ud) self.assertEqual(dsrc.metadata, md) self.assertEqual(dsrc.platform_type, 'lxd') self.assertEqual( dsrc.subplatform, 'seed-dir (%s)' % seed_dir) self.assertTrue(ret)
def test_nocloud_seed_with_vendordata(self, m_is_lxd): md = {'instance-id': 'IID', 'dsmode': 'local'} ud = b"USER_DATA_HERE" vd = b"THIS IS MY VENDOR_DATA" populate_dir(os.path.join(self.paths.seed_dir, "nocloud"), {'user-data': ud, 'meta-data': yaml.safe_dump(md), 'vendor-data': vd}) sys_cfg = { 'datasource': {'NoCloud': {'fs_label': None}} } dsrc = dsNoCloud(sys_cfg=sys_cfg, distro=None, paths=self.paths) ret = dsrc.get_data() self.assertEqual(dsrc.userdata_raw, ud) self.assertEqual(dsrc.metadata, md) self.assertEqual(dsrc.vendordata_raw, vd) self.assertTrue(ret)
def test_dev_os_remap(self): populate_dir(self.tmp, CFG_DRIVE_FILES_V2) cfg_ds = ds.DataSourceConfigDrive(settings.CFG_BUILTIN, None, helpers.Paths({})) found = ds.read_config_drive(self.tmp) cfg_ds.metadata = found['metadata'] name_tests = { 'ami': '/dev/vda1', 'root': '/dev/vda1', 'ephemeral0': '/dev/vda2', 'swap': '/dev/vda3', } for name, dev_name in name_tests.items(): with ExitStack() as mocks: provided_name = dev_name[len('/dev/'):] provided_name = "s" + provided_name[1:] find_mock = mocks.enter_context( mock.patch.object(util, 'find_devs_with', return_value=[provided_name])) # We want os.path.exists() to return False on its first call, # and True on its second call. We use a handy generator as # the mock side effect for this. The mocked function returns # what the side effect returns. def exists_side_effect(): yield False yield True exists_mock = mocks.enter_context( mock.patch.object(os.path, 'exists', side_effect=exists_side_effect())) device = cfg_ds.device_name_to_device(name) self.assertEqual(dev_name, device) find_mock.assert_called_once_with(mock.ANY) self.assertEqual(exists_mock.call_count, 2)
def test_config_write_skip_configdir(self, mock_logging): """Write configuration but skip writing 'configdir' setting""" cfg = { 'config': { 'download.deltarpm': 'False', 'reposdir': 'foo', 'configdir': 'bar' } } root_d = self.tmp_dir() helpers.populate_dir(root_d, {self.zypp_conf: '# Zypp config\n'}) self.reRoot(root_d) cc_zypper_add_repo._write_zypp_config(cfg['config']) cfg_out = os.path.join(root_d, self.zypp_conf) contents = util.load_file(cfg_out) expected = [ '# Zypp config', '# Added via cloud.cfg', 'download.deltarpm=False', 'reposdir=foo' ] for item in contents.split('\n'): if item not in expected: self.assertIsNone(item)
def test_required_missing(self): dirdata = {'f1': b'f1content'} populate_dir(self.tmp, dirdata) kwargs = {'required': ['f1', 'f2']} self.assertRaises(ValueError, util.pathprefix2dict, self.tmp, **kwargs)
def test_required_only(self): dirdata = {'f1': b'f1content', 'f2': b'f2content'} populate_dir(self.tmp, dirdata) ret = util.pathprefix2dict(self.tmp, required=['f1', 'f2']) self.assertEqual(dirdata, ret)
def test_single_azure_leases_file(self): """On Azure, option 245 should be present, verify it specifically.""" populate_dir(self.lease_d, {'1': self.azure_lease}) self.assertEqual( {'1': self.azure_parsed}, networkd_load_leases(self.lease_d))
def test_single_leases_file(self): """A leases dir with one leases file.""" populate_dir(self.lease_d, {'2': self.lxd_lease}) self.assertEqual( {'2': self.lxd_parsed}, networkd_load_leases(self.lease_d))
def call(self, rootd=None, mocks=None, func="main", args=None, files=None, policy_dmi=DI_DEFAULT_POLICY, policy_no_dmi=DI_DEFAULT_POLICY_NO_DMI, ec2_strict_id=DI_EC2_STRICT_ID_DEFAULT): if args is None: args = [] if mocks is None: mocks = [] if files is None: files = {} if rootd is None: rootd = self.tmp_dir() unset = '_unset' wrap = self.tmp_path(path="_shwrap", dir=rootd) populate_dir(rootd, files) # DI_DEFAULT_POLICY* are declared always as to not rely # on the default in the code. This is because SRU releases change # the value in the code, and thus tests would fail there. head = [ "DI_MAIN=noop", "DEBUG_LEVEL=2", "DI_LOG=stderr", "PATH_ROOT='%s'" % rootd, ". " + self.dsid_path, 'DI_DEFAULT_POLICY="%s"' % policy_dmi, 'DI_DEFAULT_POLICY_NO_DMI="%s"' % policy_no_dmi, 'DI_EC2_STRICT_ID_DEFAULT="%s"' % ec2_strict_id, "" ] def write_mock(data): ddata = {'out': None, 'err': None, 'ret': 0, 'RET': None} ddata.update(data) for k in ddata: if ddata[k] is None: ddata[k] = unset return SHELL_MOCK_TMPL % ddata mocklines = [] defaults = [ { 'name': 'detect_virt', 'RET': 'none', 'ret': 1 }, { 'name': 'uname', 'out': UNAME_MYSYS }, { 'name': 'blkid', 'out': BLKID_EFI_ROOT }, { 'name': 'ovf_vmware_transport_guestinfo', 'out': 'No value found', 'ret': 1 }, { 'name': 'dmi_decode', 'ret': 1, 'err': 'No dmidecode program. ERROR.' }, ] written = [d['name'] for d in mocks] for data in mocks: mocklines.append(write_mock(data)) for d in defaults: if d['name'] not in written: mocklines.append(write_mock(d)) endlines = [func + ' ' + ' '.join(['"%s"' % s for s in args])] with open(wrap, "w") as fp: fp.write('\n'.join(head + mocklines + endlines) + "\n") rc = 0 try: out, err = util.subp(['sh', '-c', '. %s' % wrap], capture=True) except util.ProcessExecutionError as e: rc = e.exit_code out = e.stdout err = e.stderr cfg = None cfg_out = os.path.join(rootd, 'run/cloud-init/cloud.cfg') if os.path.exists(cfg_out): contents = util.load_file(cfg_out) try: cfg = safeyaml.load(contents) except Exception as e: cfg = {"_INVALID_YAML": contents, "_EXCEPTION": str(e)} return CallReturn(rc, out, err, cfg, dir2dict(rootd))
def populate_cloud_metadata(path, data): populate_dir(path, {'cloud.json': json.dumps(data)})
def test_seed_dir_empty1_context(self): populate_dir(self.seed_dir, {'context.sh': ''}) results = ds.read_context_disk_dir(self.seed_dir, mock.Mock()) self.assertIsNone(results['userdata']) self.assertEqual(results['metadata'], {})
def populate_tmp(self, files): return t_help.populate_dir(self.tmp, files)
def populate_user_metadata(path, data): populate_dir(path, {'user.data': data})
def test_required_and_optional(self): dirdata = {'f1': b'f1c', 'f2': b'f2c'} populate_dir(self.tmp, dirdata) ret = util.pathprefix2dict(self.tmp, required=['f1'], optional=['f2']) self.assertEqual(dirdata, ret)
def test_config_only(self): """A provisioning config without a log means provisioning.""" rootd = self.tmp_dir() test_helpers.populate_dir(rootd, {self.prov_cfg: "key=value"}) self.assertTrue(self._call_with_root(rootd))
def populate_context_dir(path, variables): data = "# Context variables generated by OpenNebula\n" for k, v in variables.items(): data += ("%s='%s'\n" % (k.upper(), v.replace(r"'", r"'\''"))) populate_dir(path, {'context.sh': data})
def test_ec2_metadata(self): populate_dir(self.tmp, CFG_DRIVE_FILES_V2) found = ds.read_config_drive(self.tmp) self.assertTrue('ec2-metadata' in found) ec2_md = found['ec2-metadata'] self.assertEqual(EC2_META, ec2_md)
def test_seed_dir_broken_context(self): populate_dir(self.seed_dir, {'context.sh': INVALID_CONTEXT}) self.assertRaises(ds.BrokenContextDiskDir, ds.read_context_disk_dir, self.seed_dir, mock.Mock())
def test_option_245_is_found_in_single(self): """A single valid lease with 245 option should return it.""" populate_dir(self.lease_d, {'9': self.azure_lease}) self.assertEqual('624c3620', wa_shim._networkd_get_value_from_leases(self.lease_d))