def test_inject_data(self): orig_os_stat = os.stat def fake_stat(arg): if arg == '/some/file': # fake success return posix.stat_result((16877, 2, 2049L, 23, 0, 0, 4096, 1381787843, 1381635971, 1381635971)) else: return orig_os_stat(arg) self.useFixture(fixtures.MonkeyPatch('os.stat', fake_stat)) self.assertTrue(diskapi.inject_data("/some/file", use_cow=True)) self.assertTrue( diskapi.inject_data("/some/file", mandatory=('files', ))) self.assertTrue( diskapi.inject_data("/some/file", key="mysshkey", mandatory=('key', ))) os_name = os.name os.name = 'nt' # Cause password injection to fail self.assertRaises(exception.NovaException, diskapi.inject_data, "/some/file", admin_password="******", mandatory=('admin_password', )) self.assertFalse(diskapi.inject_data("/some/file", admin_password="******")) os.name = os_name self.assertFalse(diskapi.inject_data("/some/fail/file"))
def test_inject_into_image(self): self._create_node() files = [] self.instance['hostname'] = 'fake hostname' files.append(('/etc/hostname', 'fake hostname')) self.instance['key_data'] = 'fake ssh key' net_info = utils.get_test_network_info(1) net = tilera.build_network_config(net_info) admin_password = '******' self.mox.StubOutWithMock(disk_api, 'inject_data') disk_api.inject_data( admin_password=admin_password, image=tilera.get_image_file_path(self.instance), key='fake ssh key', metadata=None, partition=None, net=net, files=files, ).AndReturn(True) self.mox.ReplayAll() self.driver._inject_into_image( self.context, self.node, self.instance, network_info=net_info, admin_password=admin_password, injected_files=None) self.mox.VerifyAll()
def test_inject_into_image(self): # NOTE(deva): we could also test this method by stubbing # nova.virt.disk.api._inject_*_into_fs self._create_node() files = [] self.instance['hostname'] = 'fake hostname' files.append(('/etc/hostname', 'fake hostname')) self.instance['key_data'] = 'fake ssh key' net_info = utils.get_test_network_info(1) net = pxe.build_network_config(net_info) admin_password = '******' self.mox.StubOutWithMock(disk_api, 'inject_data') disk_api.inject_data( admin_password=admin_password, image=pxe.get_image_file_path(self.instance), key='fake ssh key', metadata=None, partition=None, net=net, files=files, # this is what we're really testing ).AndReturn(True) self.mox.ReplayAll() self.driver._inject_into_image(self.context, self.node, self.instance, network_info=net_info, admin_password=admin_password, injected_files=None) self.mox.VerifyAll()
def test_inject_data(self): self.assertTrue(diskapi.inject_data( imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_QCOW2))) self.assertTrue(diskapi.inject_data( imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW), mandatory=('files',))) self.assertTrue(diskapi.inject_data( imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW), key="mysshkey", mandatory=('key',))) os_name = os.name os.name = 'nt' # Cause password injection to fail self.assertRaises(exception.NovaException, diskapi.inject_data, imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW), admin_password="******", mandatory=('admin_password',)) self.assertFalse(diskapi.inject_data( imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW), admin_password="******")) os.name = os_name self.assertFalse(diskapi.inject_data( imgmodel.LocalFileImage("/some/fail/file", imgmodel.FORMAT_RAW), key="mysshkey"))
def test_inject_data(self): orig_os_stat = os.stat def fake_stat(arg): if arg == '/some/file': # fake success return stat_result((16877, 2, 2049L, 23, 0, 0, 4096, 1381787843, 1381635971, 1381635971)) else: return orig_os_stat(arg) self.useFixture(fixtures.MonkeyPatch('os.stat', fake_stat)) self.assertTrue(diskapi.inject_data("/some/file", use_cow=True)) self.assertTrue(diskapi.inject_data("/some/file", mandatory=('files',))) self.assertTrue(diskapi.inject_data("/some/file", key="mysshkey", mandatory=('key',))) os_name = os.name os.name = 'nt' # Cause password injection to fail self.assertRaises(exception.NovaException, diskapi.inject_data, "/some/file", admin_password="******", mandatory=('admin_password',)) self.assertFalse(diskapi.inject_data("/some/file", admin_password="******")) os.name = os_name self.assertFalse(diskapi.inject_data("/some/fail/file"))
def test_inject_into_image(self): # NOTE(deva): we could also test this method by stubbing # nova.virt.disk.api._inject_*_into_fs self._create_node() files = [] self.instance['hostname'] = 'fake hostname' files.append(('/etc/hostname', 'fake hostname')) self.instance['key_data'] = 'fake ssh key' net_info = utils.get_test_network_info(1) net = pxe.build_network_config(net_info) admin_password = '******' self.mox.StubOutWithMock(disk_api, 'inject_data') disk_api.inject_data( admin_password=admin_password, image=pxe.get_image_file_path(self.instance), key='fake ssh key', metadata=None, partition=None, net=net, files=files, # this is what we're really testing ).AndReturn(True) self.mox.ReplayAll() self.driver._inject_into_image( self.context, self.node, self.instance, network_info=net_info, admin_password=admin_password, injected_files=None) self.mox.VerifyAll()
def test_inject_into_image(self): self._create_node() files = [] self.instance["hostname"] = "fake hostname" files.append(("/etc/hostname", "fake hostname")) self.instance["key_data"] = "fake ssh key" net_info = utils.get_test_network_info(1) net = tilera.build_network_config(net_info) admin_password = "******" self.mox.StubOutWithMock(os.path, "exists") os.path.exists(mox.IgnoreArg()).AndReturn(True) self.mox.StubOutWithMock(disk_api, "inject_data") disk_api.inject_data( admin_password=admin_password, image=tilera.get_image_file_path(self.instance), key="fake ssh key", metadata=None, partition=None, net=net, files=files, ).AndReturn(True) self.mox.ReplayAll() self.driver._inject_into_image( self.context, self.node, self.instance, network_info=net_info, admin_password=admin_password, injected_files=None, ) self.mox.VerifyAll()
def inject_into_image(image, key, net, metadata, admin_password, files, partition, use_cow=False): try: disk_api.inject_data(image, key, net, metadata, admin_password, files, partition, use_cow) except Exception as e: LOG.warn(_("Failed to inject data into image %(image)s. " "Error: %(e)s") % locals())
def inject_into_image(image, key, net, metadata, admin_password, files, partition, use_cow=False): try: if os.path.exists(image): disk_api.inject_data(image, key, net, metadata, admin_password, files, partition, use_cow) else: LOG.warning(_('Image %s not found on disk storage. ' 'Continue without injecting data'), image) except Exception as e: LOG.warn(_("Failed to inject data into image %(image)s. " "Error: %(e)s"), {'image': image, 'e': e})
def test_inject_data(self): self.assertTrue(diskapi.inject_data("/some/file", use_cow=True)) self.assertTrue(diskapi.inject_data("/some/file", mandatory=('files',))) self.assertTrue(diskapi.inject_data("/some/file", key="mysshkey", mandatory=('key',))) os_name = os.name os.name = 'nt' # Cause password injection to fail self.assertRaises(exception.NovaException, diskapi.inject_data, "/some/file", admin_password="******", mandatory=('admin_password',)) self.assertFalse(diskapi.inject_data("/some/file", admin_password="******")) os.name = os_name
def _inject_files(self, sdk_ve, boot_hdd, instance, network_info=None, files=None, admin_pass=None): disk_path = boot_hdd.get_image_path() target_partition = CONF.pcs_inject_partition if target_partition == 0: target_partition = None key = str(instance['key_data']) net = netutils.get_injected_network_template(network_info) metadata = instance.get('metadata') if any((key, net, metadata, admin_pass, files)): # If we're not using config_drive, inject into root fs LOG.info('Injecting files') try: img_id = instance['image_ref'] for inj, val in [('key', key), ('net', net), ('metadata', metadata), ('admin_pass', admin_pass), ('files', files)]: if val: LOG.info(_('Injecting %(inj)s into image ' '%(img_id)s'), {'inj': inj, 'img_id': img_id}, instance=instance) with pcsutils.PloopMount(disk_path, chown=True, root_helper=utils._get_root_helper()) as dev: disk.inject_data(dev, key, net, metadata, admin_pass, files, partition=target_partition, use_cow=False, mandatory=('files',)) except Exception as e: with excutils.save_and_reraise_exception(): LOG.error(_('Error injecting data into image ' '%(img_id)s (%(e)s)'), {'img_id': img_id, 'e': e}, instance=instance)
def inject_into_image(image, key, net, metadata, admin_password, files, partition, use_cow=False): try: if os.path.exists(image): disk_api.inject_data(image, key, net, metadata, admin_password, files, partition, use_cow) else: LOG.warning( _('Image %s not found on disk storage. ' 'Continue without injecting data'), image) except Exception as e: LOG.warn( _("Failed to inject data into image %(image)s. " "Error: %(e)s"), { 'image': image, 'e': e })
def test_inject_into_image(self): # NOTE(deva): we could also test this method by stubbing # nova.virt.disk.api._inject_*_into_fs self._create_node() files = [] self.instance["hostname"] = "fake hostname" files.append(("/etc/hostname", "fake hostname")) self.instance["key_data"] = "fake ssh key" net_info = utils.get_test_network_info(1) net = pxe.build_network_config(net_info) admin_password = "******" self.mox.StubOutWithMock(os.path, "exists") os.path.exists(mox.IgnoreArg()).AndReturn(True) self.mox.StubOutWithMock(disk_api, "inject_data") disk_api.inject_data( admin_password=admin_password, image=pxe.get_image_file_path(self.instance), key="fake ssh key", metadata=None, partition=None, net=net, files=files, # this is what we're really testing ).AndReturn(True) self.mox.ReplayAll() self.driver._inject_into_image( self.context, self.node, self.instance, network_info=net_info, admin_password=admin_password, injected_files=None, ) self.mox.VerifyAll()
def _inject_to_image(self, context, target, node, inst, network_info, injected_files=None, admin_password=None): # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" if inst['key_data']: key = str(inst['key_data']) else: key = None net = "" nets = [] ifc_template = open(FLAGS.baremetal_injected_network_template).read() ifc_num = -1 have_injected_networks = False for (network_ref, mapping) in network_info: ifc_num += 1 # always inject #if not network_ref['injected']: # continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] name = 'eth%d' % ifc_num net_info = {'name': name, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6, 'hwaddress': mapping['mac']} nets.append(net_info) if have_injected_networks: _late_load_cheetah() net = str(Template(ifc_template, searchList=[{'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6}])) bootif_name = "eth0" net += "\n" net += "auto %s\n" % bootif_name net += "iface %s inet dhcp\n" % bootif_name admin_password = None metadata = inst.get('metadata') if any((key, net, metadata, admin_password)): inst_name = inst['name'] img_id = inst['image_ref'] for injection in ('metadata', 'key', 'net', 'admin_password'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data(target, key, net, metadata, admin_password, files=injected_files, partition=target_partition, use_cow=False) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)
def _inject_to_image(self, context, target, node, inst, network_info, injected_files=None, admin_password=None): # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" if inst['key_data']: key = str(inst['key_data']) else: key = None net = "" nets = [] ifc_template = open(FLAGS.baremetal_injected_network_template).read() ifc_num = -1 have_injected_networks = False for (network_ref, mapping) in network_info: ifc_num += 1 # always inject #if not network_ref['injected']: # continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] name = 'eth%d' % ifc_num net_info = { 'name': name, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6, 'hwaddress': mapping['mac'] } nets.append(net_info) if have_injected_networks: _late_load_cheetah() net = str( Template(ifc_template, searchList=[{ 'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6 }])) bootif_name = "eth0" net += "\n" net += "auto %s\n" % bootif_name net += "iface %s inet dhcp\n" % bootif_name admin_password = None metadata = inst.get('metadata') if any((key, net, metadata, admin_password)): inst_name = inst['name'] img_id = inst['image_ref'] for injection in ('metadata', 'key', 'net', 'admin_password'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data(target, key, net, metadata, admin_password, files=injected_files, partition=target_partition, use_cow=False) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)
def _create_image(self, context, inst, xml, suffix='', disk_images=None, network_info=None, block_device_info=None): if not suffix: suffix = '' # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, inst['name'], fname + suffix) # ensure directories exist and are writable libvirt_utils.ensure_tree(basepath(suffix='')) utils.execute('chmod', '0777', basepath(suffix='')) LOG.info(_('instance %s: Creating image'), inst['name'], instance=inst) if FLAGS.baremetal_type == 'lxc': container_dir = '%s/rootfs' % basepath(suffix='') libvirt_utils.ensure_tree(container_dir) # NOTE(vish): No need add the suffix to console.log libvirt_utils.write_to_file(basepath('console.log', ''), '', 007) if not disk_images: disk_images = { 'image_id': inst['image_ref'], 'kernel_id': inst['kernel_id'], 'ramdisk_id': inst['ramdisk_id'] } if disk_images['kernel_id']: fname = disk_images['kernel_id'] self._cache_image(fn=libvirt_utils.fetch_image, context=context, target=basepath('kernel'), fname=fname, cow=False, image_id=disk_images['kernel_id'], user_id=inst['user_id'], project_id=inst['project_id']) if disk_images['ramdisk_id']: fname = disk_images['ramdisk_id'] self._cache_image(fn=libvirt_utils.fetch_image, context=context, target=basepath('ramdisk'), fname=fname, cow=False, image_id=disk_images['ramdisk_id'], user_id=inst['user_id'], project_id=inst['project_id']) root_fname = hashlib.sha1(str(disk_images['image_id'])).hexdigest() size = inst['root_gb'] * 1024 * 1024 * 1024 inst_type_id = inst['instance_type_id'] inst_type = instance_types.get_instance_type(inst_type_id) if inst_type['name'] == 'm1.tiny' or suffix == '.rescue': size = None root_fname += "_sm" else: root_fname += "_%d" % inst['root_gb'] self._cache_image( fn=libvirt_utils.fetch_image, context=context, target=basepath('root'), fname=root_fname, cow=False, # FLAGS.use_cow_images, image_id=disk_images['image_id'], user_id=inst['user_id'], project_id=inst['project_id']) # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" if FLAGS.baremetal_type == 'lxc': target_partition = None if inst['key_data']: key = str(inst['key_data']) else: key = None net = None nets = [] ifc_template = open(FLAGS.injected_network_template).read() ifc_num = -1 have_injected_networks = False admin_context = nova_context.get_admin_context() for (network_ref, mapping) in network_info: ifc_num += 1 if not network_ref['injected']: continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] net_info = { 'name': 'eth%d' % ifc_num, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6 } nets.append(net_info) if have_injected_networks: net = str( Template(ifc_template, searchList=[{ 'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6 }])) metadata = inst.get('metadata') if any((key, net, metadata)): inst_name = inst['name'] injection_path = basepath('root') img_id = inst.image_ref disable_auto_fsck = True for injection in ('metadata', 'key', 'net'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data( injection_path, key, net, metadata, partition=target_partition, use_cow=False, # FLAGS.use_cow_images, disable_auto_fsck=disable_auto_fsck) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)
def _create_image(self, context, inst, xml, suffix="", disk_images=None, network_info=None, block_device_info=None): if not suffix: suffix = "" # syntactic nicety def basepath(fname="", suffix=suffix): return os.path.join(FLAGS.instances_path, inst["name"], fname + suffix) # ensure directories exist and are writable libvirt_utils.ensure_tree(basepath(suffix="")) utils.execute("chmod", "0777", basepath(suffix="")) LOG.info(_("instance %s: Creating image"), inst["name"], instance=inst) if FLAGS.baremetal_type == "lxc": container_dir = "%s/rootfs" % basepath(suffix="") libvirt_utils.ensure_tree(container_dir) # NOTE(vish): No need add the suffix to console.log libvirt_utils.write_to_file(basepath("console.log", ""), "", 007) if not disk_images: disk_images = { "image_id": inst["image_ref"], "kernel_id": inst["kernel_id"], "ramdisk_id": inst["ramdisk_id"], } if disk_images["kernel_id"]: fname = disk_images["kernel_id"] self._cache_image( fn=libvirt_utils.fetch_image, context=context, target=basepath("kernel"), fname=fname, cow=False, image_id=disk_images["kernel_id"], user_id=inst["user_id"], project_id=inst["project_id"], ) if disk_images["ramdisk_id"]: fname = disk_images["ramdisk_id"] self._cache_image( fn=libvirt_utils.fetch_image, context=context, target=basepath("ramdisk"), fname=fname, cow=False, image_id=disk_images["ramdisk_id"], user_id=inst["user_id"], project_id=inst["project_id"], ) root_fname = hashlib.sha1(str(disk_images["image_id"])).hexdigest() size = inst["root_gb"] * 1024 * 1024 * 1024 inst_type_id = inst["instance_type_id"] inst_type = instance_types.get_instance_type(inst_type_id) if inst_type["name"] == "m1.tiny" or suffix == ".rescue": size = None root_fname += "_sm" else: root_fname += "_%d" % inst["root_gb"] self._cache_image( fn=libvirt_utils.fetch_image, context=context, target=basepath("root"), fname=root_fname, cow=False, # FLAGS.use_cow_images, image_id=disk_images["image_id"], user_id=inst["user_id"], project_id=inst["project_id"], ) # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst["kernel_id"]: target_partition = "1" if FLAGS.baremetal_type == "lxc": target_partition = None if inst["key_data"]: key = str(inst["key_data"]) else: key = None net = None nets = [] ifc_template = open(FLAGS.injected_network_template).read() ifc_num = -1 have_injected_networks = False admin_context = nova_context.get_admin_context() for (network_ref, mapping) in network_info: ifc_num += 1 if not network_ref["injected"]: continue have_injected_networks = True address = mapping["ips"][0]["ip"] netmask = mapping["ips"][0]["netmask"] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping["ip6s"][0]["ip"] netmask_v6 = mapping["ip6s"][0]["netmask"] gateway_v6 = mapping["gateway_v6"] net_info = { "name": "eth%d" % ifc_num, "address": address, "netmask": netmask, "gateway": mapping["gateway"], "broadcast": mapping["broadcast"], "dns": " ".join(mapping["dns"]), "address_v6": address_v6, "gateway_v6": gateway_v6, "netmask_v6": netmask_v6, } nets.append(net_info) if have_injected_networks: net = str(Template(ifc_template, searchList=[{"interfaces": nets, "use_ipv6": FLAGS.use_ipv6}])) metadata = inst.get("metadata") if any((key, net, metadata)): inst_name = inst["name"] injection_path = basepath("root") img_id = inst.image_ref disable_auto_fsck = True for injection in ("metadata", "key", "net"): if locals()[injection]: LOG.info( _("instance %(inst_name)s: injecting " "%(injection)s into image %(img_id)s"), locals(), instance=inst, ) try: disk.inject_data( injection_path, key, net, metadata, partition=target_partition, use_cow=False, # FLAGS.use_cow_images, disable_auto_fsck=disable_auto_fsck, ) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn( _("instance %(inst_name)s: ignoring error injecting" " data into image %(img_id)s (%(e)s)") % locals(), instance=inst, )
def _inject_to_image(self, context, target, node, inst, network_info, injected_files=None, admin_password=None): # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" nics_in_order = [] pifs = bmdb.bm_interface_get_all_by_bm_node_id(context, node['id']) for pif in pifs: nics_in_order.append(pif['address']) nics_in_order.append(node['prov_mac_address']) # rename nics to be in the order in the DB LOG.debug("injecting persistent net") rules = "" i = 0 for hwaddr in nics_in_order: rules += 'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' \ 'ATTR{address}=="%s", ATTR{dev_id}=="0x0", ' \ 'ATTR{type}=="1", KERNEL=="eth*", NAME="eth%d"\n' \ % (hwaddr.lower(), i) i += 1 if not injected_files: injected_files = [] injected_files.append( ('/etc/udev/rules.d/70-persistent-net.rules', rules)) bootif_name = "eth%d" % (i - 1) if inst['key_data']: key = str(inst['key_data']) else: key = None net = "" nets = [] ifc_template = open(FLAGS.baremetal_injected_network_template).read() ifc_num = -1 have_injected_networks = False for (network_ref, mapping) in network_info: ifc_num += 1 # always inject #if not network_ref['injected']: # continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] name = 'eth%d' % ifc_num if FLAGS.baremetal_use_unsafe_vlan \ and mapping['should_create_vlan'] \ and network_ref.get('vlan'): name = 'eth%d.%d' % (ifc_num, network_ref.get('vlan')) net_info = { 'name': name, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6, 'hwaddress': mapping['mac'] } nets.append(net_info) if have_injected_networks: _late_load_cheetah() net = str( Template(ifc_template, searchList=[{ 'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6 }])) net += "\n" net += "auto %s\n" % bootif_name net += "iface %s inet dhcp\n" % bootif_name if not FLAGS.baremetal_inject_password: admin_password = None metadata = inst.get('metadata') if any((key, net, metadata, admin_password)): inst_name = inst['name'] img_id = inst['image_ref'] for injection in ('metadata', 'key', 'net', 'admin_password'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data(target, key, net, metadata, admin_password, files=injected_files, partition=target_partition, use_cow=False) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)
def _inject_to_image(self, context, target, node, inst, network_info, injected_files=None, admin_password=None): # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" nics_in_order = [] pifs = bmdb.bm_interface_get_all_by_bm_node_id(context, node['id']) for pif in pifs: nics_in_order.append(pif['address']) nics_in_order.append(node['prov_mac_address']) # rename nics to be in the order in the DB LOG.debug("injecting persistent net") rules = "" i = 0 for hwaddr in nics_in_order: rules += 'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' \ 'ATTR{address}=="%s", ATTR{dev_id}=="0x0", ' \ 'ATTR{type}=="1", KERNEL=="eth*", NAME="eth%d"\n' \ % (hwaddr.lower(), i) i += 1 if not injected_files: injected_files = [] injected_files.append(('/etc/udev/rules.d/70-persistent-net.rules', rules)) bootif_name = "eth%d" % (i - 1) if inst['key_data']: key = str(inst['key_data']) else: key = None net = "" nets = [] ifc_template = open(FLAGS.baremetal_injected_network_template).read() ifc_num = -1 have_injected_networks = False for (network_ref, mapping) in network_info: ifc_num += 1 # always inject #if not network_ref['injected']: # continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] name = 'eth%d' % ifc_num if FLAGS.baremetal_use_unsafe_vlan \ and mapping['should_create_vlan'] \ and network_ref.get('vlan'): name = 'eth%d.%d' % (ifc_num, network_ref.get('vlan')) net_info = {'name': name, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6, 'hwaddress': mapping['mac']} nets.append(net_info) if have_injected_networks: _late_load_cheetah() net = str(Template(ifc_template, searchList=[{'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6}])) net += "\n" net += "auto %s\n" % bootif_name net += "iface %s inet dhcp\n" % bootif_name if not FLAGS.baremetal_inject_password: admin_password = None metadata = inst.get('metadata') if any((key, net, metadata, admin_password)): inst_name = inst['name'] img_id = inst['image_ref'] for injection in ('metadata', 'key', 'net', 'admin_password'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data(target, key, net, metadata, admin_password, files=injected_files, partition=target_partition, use_cow=False) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)
def _create_image(self, context, inst, xml, suffix='', disk_images=None, network_info=None, block_device_info=None): if not suffix: suffix = '' # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, inst['name'], fname + suffix) # ensure directories exist and are writable libvirt_utils.ensure_tree(basepath(suffix='')) utils.execute('chmod', '0777', basepath(suffix='')) LOG.info(_('instance %s: Creating image'), inst['name'], instance=inst) if FLAGS.baremetal_type == 'lxc': container_dir = '%s/rootfs' % basepath(suffix='') libvirt_utils.ensure_tree(container_dir) # NOTE(vish): No need add the suffix to console.log libvirt_utils.write_to_file(basepath('console.log', ''), '', 007) if not disk_images: disk_images = {'image_id': inst['image_ref'], 'kernel_id': inst['kernel_id'], 'ramdisk_id': inst['ramdisk_id']} if disk_images['kernel_id']: fname = disk_images['kernel_id'] self._cache_image(fn=libvirt_utils.fetch_image, context=context, target=basepath('kernel'), fname=fname, cow=False, image_id=disk_images['kernel_id'], user_id=inst['user_id'], project_id=inst['project_id']) if disk_images['ramdisk_id']: fname = disk_images['ramdisk_id'] self._cache_image(fn=libvirt_utils.fetch_image, context=context, target=basepath('ramdisk'), fname=fname, cow=False, image_id=disk_images['ramdisk_id'], user_id=inst['user_id'], project_id=inst['project_id']) root_fname = hashlib.sha1(str(disk_images['image_id'])).hexdigest() size = inst['root_gb'] * 1024 * 1024 * 1024 inst_type_id = inst['instance_type_id'] inst_type = instance_types.get_instance_type(inst_type_id) if inst_type['name'] == 'm1.tiny' or suffix == '.rescue': size = None root_fname += "_sm" else: root_fname += "_%d" % inst['root_gb'] self._cache_image(fn=libvirt_utils.fetch_image, context=context, target=basepath('root'), fname=root_fname, cow=False, # FLAGS.use_cow_images, image_id=disk_images['image_id'], user_id=inst['user_id'], project_id=inst['project_id']) # For now, we assume that if we're not using a kernel, we're using a # partitioned disk image where the target partition is the first # partition target_partition = None if not inst['kernel_id']: target_partition = "1" if FLAGS.baremetal_type == 'lxc': target_partition = None if inst['key_data']: key = str(inst['key_data']) else: key = None net = None nets = [] ifc_template = open(FLAGS.injected_network_template).read() ifc_num = -1 have_injected_networks = False admin_context = nova_context.get_admin_context() for (network_ref, mapping) in network_info: ifc_num += 1 if not network_ref['injected']: continue have_injected_networks = True address = mapping['ips'][0]['ip'] netmask = mapping['ips'][0]['netmask'] address_v6 = None gateway_v6 = None netmask_v6 = None if FLAGS.use_ipv6: address_v6 = mapping['ip6s'][0]['ip'] netmask_v6 = mapping['ip6s'][0]['netmask'] gateway_v6 = mapping['gateway_v6'] net_info = {'name': 'eth%d' % ifc_num, 'address': address, 'netmask': netmask, 'gateway': mapping['gateway'], 'broadcast': mapping['broadcast'], 'dns': ' '.join(mapping['dns']), 'address_v6': address_v6, 'gateway_v6': gateway_v6, 'netmask_v6': netmask_v6} nets.append(net_info) if have_injected_networks: net = str(Template(ifc_template, searchList=[{'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6}])) metadata = inst.get('metadata') if any((key, net, metadata)): inst_name = inst['name'] injection_path = basepath('root') img_id = inst['image_ref'] for injection in ('metadata', 'key', 'net'): if locals()[injection]: LOG.info(_('instance %(inst_name)s: injecting ' '%(injection)s into image %(img_id)s'), locals(), instance=inst) try: disk.inject_data(injection_path, key, net, metadata, partition=target_partition, use_cow=False) # FLAGS.use_cow_images except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' ' data into image %(img_id)s (%(e)s)') % locals(), instance=inst)