# Copyright 2013 Cloudbase Solutions Srl # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """ Image caching and management. """ import os import re from nova import exception from nova import utils from nova.virt import imagecache from nova.virt import images from os_win import utilsfactory from oslo_log import log as logging from oslo_utils import excutils from oslo_utils import units from oslo_utils import uuidutils from compute_hyperv.i18n import _ import compute_hyperv.nova.conf from compute_hyperv.nova import pathutils LOG = logging.getLogger(__name__) CONF = compute_hyperv.nova.conf.CONF class ImageCache(imagecache.ImageCacheManager): def __init__(self): super(ImageCache, self).__init__() self._pathutils = pathutils.PathUtils() self._vhdutils = utilsfactory.get_vhdutils() self.used_images = [] self.unexplained_images = [] self.originals = [] def _get_root_vhd_size_gb(self, instance): if instance.old_flavor: return instance.old_flavor.root_gb else: return instance.flavor.root_gb def _resize_and_cache_vhd(self, instance, vhd_path): vhd_size = self._vhdutils.get_vhd_size(vhd_path)['VirtualSize'] root_vhd_size_gb = self._get_root_vhd_size_gb(instance) root_vhd_size = root_vhd_size_gb * units.Gi root_vhd_internal_size = ( self._vhdutils.get_internal_vhd_size_by_file_size( vhd_path, root_vhd_size)) if root_vhd_internal_size < vhd_size: raise exception.FlavorDiskSmallerThanImage( flavor_size=root_vhd_size, image_size=vhd_size) if root_vhd_internal_size > vhd_size: path_parts = os.path.splitext(vhd_path) resized_vhd_path = '%s_%s%s' % (path_parts[0], root_vhd_size_gb, path_parts[1]) lock_path = os.path.dirname(resized_vhd_path) lock_name = "%s-cache.lock" % os.path.basename(resized_vhd_path) @utils.synchronized(name=lock_name, external=True, lock_path=lock_path) def copy_and_resize_vhd(): if not self._pathutils.exists(resized_vhd_path): try: LOG.debug("Copying VHD %(vhd_path)s to " "%(resized_vhd_path)s", {'vhd_path': vhd_path, 'resized_vhd_path': resized_vhd_path}) self._pathutils.copyfile(vhd_path, resized_vhd_path) LOG.debug("Resizing VHD %(resized_vhd_path)s to new " "size %(root_vhd_size)s", {'resized_vhd_path': resized_vhd_path, 'root_vhd_size': root_vhd_size}) self._vhdutils.resize_vhd(resized_vhd_path, root_vhd_internal_size, is_file_max_size=False) except Exception: with excutils.save_and_reraise_exception(): if self._pathutils.exists(resized_vhd_path): self._pathutils.remove(resized_vhd_path) copy_and_resize_vhd() return resized_vhd_path def get_cached_image(self, context, instance, rescue_image_id=None): image_id = rescue_image_id or instance.image_ref image_type = instance.system_metadata['image_disk_format'] base_image_dir = self._pathutils.get_base_vhd_dir() base_image_path = os.path.join(base_image_dir, image_id) lock_name = "%s-cache.lock" % image_id @utils.synchronized(name=lock_name, external=True, lock_path=base_image_dir) def fetch_image_if_not_existing(): image_path = None for format_ext in ['vhd', 'vhdx', 'iso']: test_path = base_image_path + '.' + format_ext if self._pathutils.exists(test_path): image_path = test_path self._update_image_timestamp(image_id) break if not image_path: try: images.fetch(context, image_id, base_image_path) if image_type == 'iso': format_ext = 'iso' else: format_ext = self._vhdutils.get_vhd_format( base_image_path) image_path = base_image_path + '.' + format_ext.lower() self._pathutils.rename(base_image_path, image_path) except Exception: with excutils.save_and_reraise_exception(): if self._pathutils.exists(base_image_path): self._pathutils.remove(base_image_path) return image_path image_path = fetch_image_if_not_existing() # Note: rescue images are not resized. is_vhd = image_path.split('.')[-1].lower() == 'vhd' if (CONF.use_cow_images and is_vhd and not rescue_image_id): # Resize the base VHD image as it's not possible to resize a # differencing VHD. This does not apply to VHDX images. resized_image_path = self._resize_and_cache_vhd(instance, image_path) if resized_image_path: return resized_image_path if rescue_image_id: self._verify_rescue_image(instance, rescue_image_id, image_path) return image_path def _verify_rescue_image(self, instance, rescue_image_id, rescue_image_path): rescue_image_info = self._vhdutils.get_vhd_info(rescue_image_path) rescue_image_size = rescue_image_info['VirtualSize'] flavor_disk_size = instance.flavor.root_gb * units.Gi if rescue_image_size > flavor_disk_size: err_msg = _('Using a rescue image bigger than the instance ' 'flavor disk size is not allowed. ' 'Rescue image size: %(rescue_image_size)s. ' 'Flavor disk size:%(flavor_disk_size)s.') % dict( rescue_image_size=rescue_image_size, flavor_disk_size=flavor_disk_size) raise exception.ImageUnacceptable(reason=err_msg, image_id=rescue_image_id) def get_image_details(self, context, instance): image_id = instance.image_ref return images.get_info(context, image_id) def _age_and_verify_cached_images(self, context, all_instances, base_dir): for img in self.originals: if img in self.used_images: # change the timestamp on the image so as to reflect the last # time it was used self._update_image_timestamp(img) elif CONF.remove_unused_base_images: self._remove_if_old_image(img) def _update_image_timestamp(self, image): backing_files = self._get_image_backing_files(image) for img in backing_files: os.utime(img, None) def _get_image_backing_files(self, image): base_file = self._pathutils.get_image_path(image) if not base_file: # not vhd or vhdx, ignore. return [] backing_files = [base_file] resize_re = re.compile('%s_[0-9]+$' % image) for img in self.unexplained_images: match = resize_re.match(img) if match: backing_files.append(self._pathutils.get_image_path(img)) return backing_files def _remove_if_old_image(self, image): backing_files = self._get_image_backing_files(image) max_age_seconds = CONF.remove_unused_original_minimum_age_seconds for img in backing_files: age_seconds = self._pathutils.get_age_of_file(img) if age_seconds > max_age_seconds: LOG.info("Removing old, unused image: %s", img) self._remove_old_image(img) def _remove_old_image(self, image_path): lock_path = os.path.dirname(image_path) lock_name = "%s-cache.lock" % os.path.basename(image_path) @utils.synchronized(name=lock_name, external=True, lock_path=lock_path) def _image_synchronized_remove(): self._pathutils.remove(image_path) _image_synchronized_remove() def update(self, context, all_instances): base_vhd_dir = self._pathutils.get_base_vhd_dir() running = self._list_running_instances(context, all_instances) self.used_images = running['used_images'].keys() all_files = self._list_base_images(base_vhd_dir) self.originals = all_files['originals'] self.unexplained_images = all_files['unexplained_images'] self._age_and_verify_cached_images(context, all_instances, base_vhd_dir) def _list_base_images(self, base_dir): unexplained_images = [] originals = [] for entry in os.listdir(base_dir): file_name, extension = os.path.splitext(entry) # extension has a leading '.'. E.g.: '.vhdx' if extension.lstrip('.').lower() not in ['vhd', 'vhdx']: # File is not an image. Ignore it. # imagecache will not store images of any other formats. continue if uuidutils.is_uuid_like(file_name): originals.append(file_name) else: unexplained_images.append(file_name) return {'unexplained_images': unexplained_images, 'originals': originals}