def _cache_image(fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. This wrapper will save the image into a common store and create a copy for use by the hypervisor. The underlying method should specify a kwarg of target representing where the image will be saved. fname is used as the filename of the base image. The filename needs to be unique to a given image. If cow is True, it will make a CoW image instead of a copy. """ if not os.path.exists(target): base_dir = os.path.join(FLAGS.instances_path, "_base") if not os.path.exists(base_dir): libvirt_utils.ensure_tree(base_dir) base = os.path.join(base_dir, fname) @utils.synchronized(fname) def call_if_not_exists(base, fn, *args, **kwargs): if not os.path.exists(base): fn(target=base, *args, **kwargs) call_if_not_exists(base, fn, *args, **kwargs) if cow: libvirt_utils.create_cow_image(base, target) else: libvirt_utils.copy_image(base, target)
def create_image(self, var, context, image_meta, node, instance, injected_files=None, admin_password=None): image_root = var['image_root'] network_info = var['network_info'] ami_id = str(image_meta['id']) libvirt_utils.ensure_tree(image_root) image_path = os.path.join(image_root, 'disk') LOG.debug("fetching image id=%s target=%s", ami_id, image_path) _cache_image_x(context=context, target=image_path, image_id=ami_id, user_id=instance['user_id'], project_id=instance['project_id']) LOG.debug("injecting to image id=%s target=%s", ami_id, image_path) self._inject_to_image(context, image_path, node, instance, network_info, injected_files=injected_files, admin_password=admin_password) var['image_path'] = image_path LOG.debug("fetching images all done")
def _cache_image(fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. This wrapper will save the image into a common store and create a copy for use by the hypervisor. The underlying method should specify a kwarg of target representing where the image will be saved. fname is used as the filename of the base image. The filename needs to be unique to a given image. If cow is True, it will make a CoW image instead of a copy. """ if not os.path.exists(target): base_dir = os.path.join(FLAGS.instances_path, '_base') if not os.path.exists(base_dir): libvirt_utils.ensure_tree(base_dir) base = os.path.join(base_dir, fname) @utils.synchronized(fname) def call_if_not_exists(base, fn, *args, **kwargs): if not os.path.exists(base): fn(target=base, *args, **kwargs) call_if_not_exists(base, fn, *args, **kwargs) if cow: libvirt_utils.create_cow_image(base, target) else: libvirt_utils.copy_image(base, target)
def cache(self, fn, fname, size=None, *args, **kwargs): """Creates image from template. Ensures that template and image not already exists. Ensures that base directory exists. Synchronizes on template fetching. :fn: function, that creates template. Should accept `target` argument. :fname: Template name :size: Size of created image in bytes (optional) """ @utils.synchronized(fname) def call_if_not_exists(target, *args, **kwargs): if not os.path.exists(target): fn(target=target, *args, **kwargs) if not os.path.exists(self.path): base_dir = os.path.join(FLAGS.instances_path, '_base') if not os.path.exists(base_dir): libvirt_utils.ensure_tree(base_dir) base = os.path.join(base_dir, fname) self.create_image(call_if_not_exists, base, size, *args, **kwargs)
def _add_file(self, path, data, inject=False): if inject: path_id = '%03d' % self.next_inject_id path = 'openstack/files/%s' % path_id self.injected[path] = path_id self.next_inject_id += 1 filepath = os.path.join(self.tempdir, path) dirname = os.path.dirname(filepath) virtutils.ensure_tree(dirname) with open(filepath, 'w') as f: f.write(data)
def _add_file(self, path, data): filepath = os.path.join(self.tempdir, path) dirname = os.path.dirname(filepath) virtutils.ensure_tree(dirname) with open(filepath, 'w') as f: f.write(data)
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']) 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'], size=size) # 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()) 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())
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']) 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'], size=size) # 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())) 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())