upstream/oracle/userland-gate: comparison components/openstack/nova/files/solariszones/driver.py

equal deleted inserted replaced

-:4be1f488dda8
+:db0cec748ec0
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
 # Copyright 2011 Justin Santa Barbara
 # All Rights Reserved.
 #
-# Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2013, 2015, Oracle and/or its affiliates. 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
 #
 from oslo.config import cfg
 from nova.compute import power_state
 from nova.compute import task_states
 from nova.compute import vm_states
+from nova.console import type as ctype
 from nova import conductor
 from nova import context as nova_context
 from nova import exception
+from nova.i18n import _
 from nova.image import glance
 from nova.network import neutronv2
+from nova.objects import flavor as flavor_obj
 from nova.openstack.common import fileutils
-from nova.openstack.common.gettextutils import _
 from nova.openstack.common import jsonutils
 from nova.openstack.common import log as logging
 from nova.openstack.common import loopingcall
 from nova.openstack.common import processutils
 from nova.openstack.common import strutils
 """
 capabilities = {
 "has_imagecache": False,
 "supports_recreate": False,
 }
 def __init__(self, virtapi):
 self.virtapi = virtapi
 self._compute_event_callback = None
 self._conductor_api = conductor.API()
 self._fc_wwpns = None
 self._host_stats = {}
 self._initiator = None
 self._install_engine = None
 self._pagesize = os.sysconf('SC_PAGESIZE')
+self._rad_connection = None
 self._uname = os.uname()
 self._validated_archives = list()
 self._volume_api = volume.API()
+@property
+def rad_connection(self):
+if self._rad_connection is None:
+self._rad_connection = rad.connect.connect_unix()
+else:
+# taken from rad.connect.RadConnection.__repr__ to look for a
+# closed connection
+if self._rad_connection._closed is not None:
+# the RAD connection has been lost.  Reconnect to RAD
+self._rad_connection = rad.connect.connect_unix()
+return self._rad_connection
 def _init_rad(self):
 """Connect to RAD providers for kernel statistics and Solaris
 Zones. By connecting to the local rad(1M) service through a
 UNIX domain socket, kernel statistics can be read via
 kstat(3RAD) and Solaris Zones can be configured and controlled
 via zonemgr(3RAD).
 """
-# TODO(dcomay): Arrange to call this in the event of losing the
+try:
-# connection to RAD.
+self._kstat_control = self.rad_connection.get_object(
-try:
-self._rad_instance = rad.connect.connect_unix()
-self._kstat_control = self._rad_instance.get_object(
 kstat.Control())
 except Exception as reason:
 msg = (_('Unable to connect to svc:/system/rad:local: %s')
 % reason)
 raise exception.NovaException(msg)
 """Initialize anything that is necessary for the driver to function,
 including catching up with currently running VM's on the given host.
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 self._init_rad()
+def cleanup_host(self, host):
+"""Clean up anything that is necessary for the driver gracefully stop,
+including ending remote sessions. This is optional.
+"""
+pass
 def _get_fc_hbas(self):
 """Get Fibre Channel HBA information."""
 if self._fc_hbas:
 return self._fc_hbas
 return None
 def _get_zone_by_name(self, name):
 """Return a Solaris Zones object via RAD by name."""
 try:
-zone = self._rad_instance.get_object(
+zone = self.rad_connection.get_object(
 zonemgr.Zone(), rad.client.ADRGlobPattern({'name': name}))
 except rad.client.NotFoundError:
 return None
 except Exception:
 raise
 def _get_max_mem(self, zone):
 """Return the maximum memory in KBytes allowed."""
 max_mem = lookup_resource_property(zone, 'capped-memory', 'physical')
 if max_mem is not None:
-return strutils.to_bytes(max_mem) / 1024
+return strutils.string_to_bytes("%sB" % max_mem) / 1024
 # If physical property in capped-memory doesn't exist, this may
 # represent a non-global zone so just return the system's total
 # memory.
 return self._pages_to_kb(os.sysconf('SC_PHYS_PAGES'))
 'instance': instance,
 'name':     name
 }
 try:
 self._kstat_control.update()
-kstat_object = self._rad_instance.get_object(
+kstat_object = self.rad_connection.get_object(
 kstat.Kstat(), rad.client.ADRGlobPattern(pattern))
 except Exception as reason:
 LOG.info(_("Unable to retrieve kstat object '%s:%s:%s' of class "
 "'%s' via kstat(3RAD): %s")
 % (module, instance, name, kstat_class, reason))
 return kstat_data['cpu_nsec_kernel'] + kstat_data['cpu_nsec_user']
 def get_info(self, instance):
 """Get the current status of an instance, by name (not ID!)
+:param instance: nova.objects.instance.Instance object
 Returns a dict containing:
 :state:           the running state, one of the power_state codes
 :max_mem:         (int) the maximum memory in KBytes allowed
 encouraged to override this method with something more
 efficient.
 """
 return len(self.list_instances())
-def instance_exists(self, instance_id):
+def instance_exists(self, instance):
 """Checks existence of an instance on the host.
-:param instance_id: The ID / name of the instance to lookup
+:param instance: The instance to lookup
 Returns True if an instance with the supplied ID exists on
 the host, False otherwise.
 .. note::
 This implementation works for all drivers, but it is
 not particularly efficient. Maintainers of the virt drivers are
 encouraged to override this method with something more
 efficient.
 """
-return instance_id in self.list_instances()
+try:
+return instance.uuid in self.list_instance_uuids()
+except NotImplementedError:
+return instance.name in self.list_instances()
 def estimate_instance_overhead(self, instance_info):
 """Estimate the virtualization overhead required to build an instance
 of the given flavor.
 """
 return {'memory_mb': 0}
 def _get_list_zone_object(self):
 """Return a list of all Solaris Zones objects via RAD."""
-return self._rad_instance.list_objects(zonemgr.Zone())
+return self.rad_connection.list_objects(zonemgr.Zone())
 def list_instances(self):
-"""
+"""Return the names of all the instances known to the virtualization
-Return the names of all the instances known to the virtualization
 layer, as a list.
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 instances_list = []
 for zone in self._get_list_zone_object():
-instances_list.append(self._rad_instance.get_object(zone).name)
+instances_list.append(self.rad_connection.get_object(zone).name)
 return instances_list
 def list_instance_uuids(self):
-"""
+"""Return the UUIDS of all the instances known to the virtualization
-Return the UUIDS of all the instances known to the virtualization
 layer, as a list.
+"""
+raise NotImplementedError()
+def rebuild(self, context, instance, image_meta, injected_files,
+admin_password, bdms, detach_block_devices,
+attach_block_devices, network_info=None,
+recreate=False, block_device_info=None,
+preserve_ephemeral=False):
+"""Destroy and re-make this instance.
+A 'rebuild' effectively purges all existing data from the system and
+remakes the VM with given 'metadata' and 'personalities'.
+This base class method shuts down the VM, detaches all block devices,
+then spins up the new VM afterwards. It may be overridden by
+hypervisors that need to - e.g. for optimisations, or when the 'VM'
+is actually proxied and needs to be held across the shutdown + spin
+up steps.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+This function should use the data there to guide
+the creation of the new instance.
+:param image_meta: image object returned by nova.image.glance that
+defines the image from which to boot this instance
+:param injected_files: User files to inject into instance.
+:param admin_password: Administrator password to set in instance.
+:param bdms: block-device-mappings to use for rebuild
+:param detach_block_devices: function to detach block devices. See
+nova.compute.manager.ComputeManager:_rebuild_default_impl for
+usage.
+:param attach_block_devices: function to attach block devices. See
+nova.compute.manager.ComputeManager:_rebuild_default_impl for
+usage.
+:param network_info:
+:py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
+:param recreate: True if the instance is being recreated on a new
+hypervisor - all the cleanup of old state is skipped.
+:param block_device_info: Information about block devices to be
+attached to the instance.
+:param preserve_ephemeral: True if the default ephemeral storage
+partition must be preserved on rebuild
 """
 raise NotImplementedError()
 def _fetch_image(self, context, instance):
 """Fetch an image using Glance given the instance's image_ref."""
 zone = self._get_zone_by_name(name)
 if zone is None:
 raise exception.InstanceNotFound(instance_id=name)
 tenant_id = None
+network_plugin = neutronv2.get_client(context)
 for netid, network in enumerate(network_info):
 if tenant_id is None:
 tenant_id = network['network']['meta']['tenant_id']
-network_uuid = network['network']['id']
 port_uuid = network['id']
+port = network_plugin.show_port(port_uuid)['port']
+evs_uuid = port['network_id']
+vport_uuid = port['id']
 ip = network['network']['subnets'][0]['ips'][0]['address']
 ip_version = network['network']['subnets'][0]['version']
 route = network['network']['subnets'][0]['gateway']['address']
 dns_list = network['network']['subnets'][0]['dns']
 nameservers = []
 nameservers.append(dns['address'])
 with ZoneConfig(zone) as zc:
 if netid == 0:
 zc.setprop('anet', 'configure-allowed-address', 'false')
-zc.setprop('anet', 'evs', network_uuid)
+zc.setprop('anet', 'evs', evs_uuid)
-zc.setprop('anet', 'vport', port_uuid)
+zc.setprop('anet', 'vport', vport_uuid)
 else:
 zc.addresource(
 'anet',
 [zonemgr.Property('configure-allowed-address',
 'false'),
-zonemgr.Property('evs', network_uuid),
+zonemgr.Property('evs', evs_uuid),
-zonemgr.Property('vport', port_uuid)])
+zonemgr.Property('vport', vport_uuid)])
-filter = [zonemgr.Property('vport', port_uuid)]
+filter = [zonemgr.Property('vport', vport_uuid)]
 if brand == ZONE_BRAND_SOLARIS:
 linkname = lookup_resource_property(zc.zone, 'anet',
 'linkname', filter)
 else:
 id = lookup_resource_property(zc.zone, 'anet', 'id',
 filter)
 linkname = 'net%s' % id
 # create the required sysconfig file
-network_plugin = neutronv2.get_client(context)
-port = network_plugin.show_port(port_uuid)['port']
 subnet_uuid = port['fixed_ips'][0]['subnet_id']
 subnet = network_plugin.show_subnet(subnet_uuid)['subnet']
 if subnet['enable_dhcp']:
 tree = sysconfig.create_ncp_defaultfixed('dhcp', linkname,
 elif os.path.isdir(sc_profile):
 shutil.copytree(sc_profile, os.path.join(sc_dir, 'sysconfig'))
 self._verify_sysconfig(sc_dir, instance)
-zonemanager = self._rad_instance.get_object(zonemgr.ZoneManager())
+zonemanager = self.rad_connection.get_object(zonemgr.ZoneManager())
 try:
 zonemanager.create(name, None, template)
 self._set_global_properties(name, extra_specs, brand)
 if connection_info:
 self._set_boot_device(name, connection_info, brand)
 """Delete an existing Solaris Zone configuration."""
 name = instance['name']
 if self._get_zone_by_name(name) is None:
 raise exception.InstanceNotFound(instance_id=name)
-zonemanager = self._rad_instance.get_object(zonemgr.ZoneManager())
+zonemanager = self.rad_connection.get_object(zonemgr.ZoneManager())
 try:
 zonemanager.delete(name)
 except Exception as reason:
 LOG.error(_("Unable to delete configuration for instance '%s' via "
 "zonemgr(3RAD): %s") % (name, reason))
 raise
 def spawn(self, context, instance, image_meta, injected_files,
 admin_password, network_info=None, block_device_info=None):
-"""
+"""Create a new instance/VM/domain on the virtualization platform.
-Create a new instance/VM/domain on the virtualization platform.
 Once this successfully completes, the instance should be
 running (power_state.RUNNING).
 If this fails, any partial instance should be completely
 cleaned up, and the virtualization platform should be in the state
 that it was before this call began.
 :param context: security context
-:param instance: Instance object as returned by DB layer.
+:param instance: nova.objects.instance.Instance
 This function should use the data there to guide
 the creation of the new instance.
 :param image_meta: image object returned by nova.image.glance that
 defines the image from which to boot this instance
 :param injected_files: User files to inject into instance.
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param block_device_info: Information about block devices to be
 attached to the instance.
 """
-inst_type = self.virtapi.instance_type_get(
+inst_type = flavor_obj.Flavor.get_by_id(
 nova_context.get_admin_context(read_deleted='yes'),
 instance['instance_type_id'])
 extra_specs = inst_type['extra_specs'].copy()
 image = self._fetch_image(context, instance)
 # Attempt to provision a (Cinder) volume service backed boot volume
 connection_info = self._connect_boot_volume(context, instance,
 extra_specs)
 name = instance['name']
-def _ai_health_check(zone):
-# TODO(npower) A hung kernel zone installation will not always
-# be detected by zoneadm in the host global zone, which locks
-# out other zoneadm commands.
-# Workaround:
-# Check the state of the auto-installer:default SMF service in
-# the kernel zone. If installation failed, it should be in the
-# 'maintenance' state. Unclog zoneadm by executing a shutdown
-# inside the kernel zone if that's the case.
-# Eventually we'll be able to pass a boot option to the zone
-# to have it automatically shutdown if the installation fails.
-if instance['vm_state'] == vm_states.BUILDING:
-if self._get_zone_auto_install_state(name) == 'maintenance':
-# Poweroff the zone. This will cause the current call to
-# self._install() to catch an exception and tear down
-# the kernel zone.
-LOG.error(_("Automated installation of instance '%s' "
-"failed. Powering off the kernel zone '%s'.")
-% (instance['display_name'], name))
-try:
-utils.execute('/usr/sbin/zlogin', '-S', name,
-'/usr/sbin/poweroff')
-except processutils.ProcessExecutionError as err:
-# poweroff pulls the rug from under zlogin, so ignore
-# the anticipated error.
-pass
-finally:
-raise loopingcall.LoopingCallDone()
-else:
-# Looks like it installed OK
-if zone.state == ZONE_STATE_INSTALLED:
-LOG.debug(_("Kernel zone '%s' (%s) state: %s.")
-% (name, instance['display_name'],
-zone.state))
-raise loopingcall.LoopingCallDone()
-else:
-return
-else:
-# Can't imagine why we'd get here under normal circumstances
-LOG.warning(_("Unexpected vm_state during installation of "
-"'%s' (%s): %s. Zone state: %s")
-% (name, instance['display_name'],
-instance['vm_state'], zone.state))
-raise loopingcall.LoopingCallDone()
 LOG.debug(_("creating zone configuration for '%s' (%s)") %
 (name, instance['display_name']))
 self._create_config(context, instance, network_info,
 connection_info, extra_specs, sc_dir)
 try:
-zone = self._get_zone_by_name(name)
+self._install(instance, image, extra_specs, sc_dir)
-is_kz = lookup_resource_property_value(zone, "global", "brand",
-ZONE_BRAND_SOLARIS_KZ)
-# Monitor kernel zone installation explicitly
-if is_kz:
-monitor = loopingcall.FixedIntervalLoopingCall(
-_ai_health_check, zone)
-monitor.start(interval=15, initial_delay=60)
-self._install(instance, image, extra_specs, sc_dir)
-monitor.wait()
-else:
-self._install(instance, image, extra_specs, sc_dir)
 self._power_on(instance)
 except Exception as reason:
 LOG.error(_("Unable to spawn instance '%s' via zonemgr(3RAD): %s")
 % (name, reason))
 self._uninstall(instance)
 try:
 if halt_type == 'SOFT':
 zone.shutdown()
 else:
 # 'HARD'
-# TODO(npower) See comments for _ai_health_check() for why
+zone.halt()
-# it is sometimes necessary to poweroff from within the zone,
-# until zoneadm and auto-install can perform this internally.
-zprop = lookup_resource_property_value(zone, "global", "brand",
-ZONE_BRAND_SOLARIS_KZ)
-if zprop and self._get_zone_auto_install_state(name):
-# Don't really care what state the install service is in.
-# Just shut it down ASAP.
-try:
-utils.execute('/usr/sbin/zlogin', '-S', name,
-'/usr/sbin/poweroff')
-except processutils.ProcessExecutionError as err:
-# Poweroff pulls the rug from under zlogin, so ignore
-# the anticipated error.
-return
-else:
-zone.halt()
-return
 except rad.client.ObjectError as reason:
 result = reason.get_payload()
 if result.code == zonemgr.ErrorCode.COMMAND_ERROR:
 LOG.warning(_("Ignoring command error returned while trying "
 "to power off instance '%s' via zonemgr(3RAD): "
 except Exception as reason:
 LOG.error(_("Unable to power off instance '%s' via zonemgr(3RAD): "
 "%s") % (name, reason))
 raise exception.InstancePowerOffFailure(reason=reason)
-def destroy(self, instance, network_info, block_device_info=None,
+def destroy(self, context, instance, network_info, block_device_info=None,
-destroy_disks=True, context=None):
+destroy_disks=True, migrate_data=None):
-"""Destroy (shutdown and delete) the specified instance.
+"""Destroy the specified instance from the Hypervisor.
 If the instance is not found (for example if networking failed), this
 function should still succeed.  It's probably a good idea to log a
 warning in that case.
+:param context: security context
 :param instance: Instance object as returned by DB layer.
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param block_device_info: Information about block devices that should
 be detached from the instance.
 :param destroy_disks: Indicates if disks should be destroyed
+:param migrate_data: implementation specific params
 """
-# TODO(Vek): Need to pass context in for access to auth_token
 try:
 # These methods log if problems occur so no need to double log
 # here. Just catch any stray exceptions and allow destroy to
 # proceed.
 if self._has_vnc_console_service(instance):
 self._delete_config(instance)
 except Exception as reason:
 LOG.warning(_("Unable to destroy instance '%s' via zonemgr(3RAD): "
 "%s") % (name, reason))
+def cleanup(self, context, instance, network_info, block_device_info=None,
+destroy_disks=True, migrate_data=None, destroy_vifs=True):
+"""Cleanup the instance resources .
+Instance should have been destroyed from the Hypervisor before calling
+this method.
+:param context: security context
+:param instance: Instance object as returned by DB layer.
+:param network_info:
+:py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
+:param block_device_info: Information about block devices that should
+be detached from the instance.
+:param destroy_disks: Indicates if disks should be destroyed
+:param migrate_data: implementation specific params
+"""
+raise NotImplementedError()
 def reboot(self, context, instance, network_info, reboot_type,
 block_device_info=None, bad_volumes_callback=None):
 """Reboot the specified instance.
 After this is called successfully, the instance's state
 goes back to power_state.RUNNING. The virtualization
 platform should ensure that the reboot action has completed
 successfully even in cases in which the underlying domain/vm
 is paused or halted/stopped.
-:param instance: Instance object as returned by DB layer.
+:param instance: nova.objects.instance.Instance
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param reboot_type: Either a HARD or SOFT reboot
 :param block_device_info: Info pertaining to attached volumes
 :param bad_volumes_callback: Function to handle any bad volumes
 for line in log.readlines():
 fragment += line
 console_str = fragment + console_str
 return console_str
-def get_console_output(self, instance):
+def get_console_output(self, context, instance):
-# TODO(Vek): Need to pass context in for access to auth_token
+"""Get console output for an instance
+:param context: security context
+:param instance: nova.objects.instance.Instance
+"""
 return self._get_console_output(instance)
-def get_vnc_console(self, instance):
+def get_vnc_console(self, context, instance):
-# TODO(Vek): Need to pass context in for access to auth_token
+"""Get connection info for a vnc console.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+:returns an instance of console.type.ConsoleVNC
+"""
 # Do not provide console access prematurely. Zone console access is
 # exclusive and zones that are still installing require their console.
 # Grabbing the zone console will break installation.
 name = instance['name']
 if instance['vm_state'] == vm_states.BUILDING:
 raise
 try:
 out, err = utils.execute('/usr/bin/svcprop', '-p', 'vnc/port',
 console_fmri)
-port = out.strip()
+port = int(out.strip())
-return {'host': '127.0.0.1', 'port': port,
+return ctype.ConsoleVNC(host='127.0.0.1',
-'internal_access_path': None}
+port=port,
+internal_access_path=None)
 except processutils.ProcessExecutionError as err:
 LOG.error(_("Unable to read VNC console port from zone VNC "
 "console SMF service '%s': %s"
 % (console_fmri, err)))
-def get_spice_console(self, instance):
+def get_spice_console(self, context, instance):
-# TODO(Vek): Need to pass context in for access to auth_token
+"""Get connection info for a spice console.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+:returns an instance of console.type.ConsoleSpice
+"""
+raise NotImplementedError()
+def get_rdp_console(self, context, instance):
+"""Get connection info for a rdp console.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+:returns an instance of console.type.ConsoleRDP
+"""
+raise NotImplementedError()
+def get_serial_console(self, context, instance):
+"""Get connection info for a serial console.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+:returns an instance of console.type.ConsoleSerial
+"""
 raise NotImplementedError()
 def _get_zone_diagnostics(self, zone):
 """Return data about Solaris Zone diagnostics."""
 if zone.id == -1:
 if key not in ('class', 'crtime', 'snaptime'):
 diagnostics[key] = kstat_data[key]
 return diagnostics
 def get_diagnostics(self, instance):
-"""Return data about VM diagnostics."""
+"""Return data about VM diagnostics.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 name = instance['name']
 zone = self._get_zone_by_name(name)
 if zone is None:
 LOG.error(_("Unable to find instance '%s' via zonemgr(3RAD)")
 % name)
 raise exception.InstanceNotFound(instance_id=name)
 return self._get_zone_diagnostics(zone)
+def get_instance_diagnostics(self, instance):
+"""Return data about VM diagnostics.
+:param instance: nova.objects.instance.Instance
+"""
+raise NotImplementedError()
 def get_all_bw_counters(self, instances):
 """Return bandwidth usage counters for each interface on each
 running VM.
+:param instances: nova.objects.instance.InstanceList
 """
 raise NotImplementedError()
 def get_all_volume_usage(self, context, compute_host_bdms):
 """Return usage info for volumes attached to vms on
 a given host.-
 """
 raise NotImplementedError()
 def get_host_ip_addr(self):
-"""
+"""Retrieves the IP address of the dom0
-Retrieves the IP address of the dom0
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 return CONF.my_ip
 def attach_volume(self, context, connection_info, instance, mountpoint,
-encryption=None):
+disk_bus=None, device_type=None, encryption=None):
 """Attach the disk to the instance at mountpoint using info."""
 # TODO(npower): Apply mountpoint in a meaningful way to the zone
 # (I don't think this is even possible for Solaris brand zones)
 name = instance['name']
 zone = self._get_zone_by_name(name)
 with ZoneConfig(zone) as zc:
 zc.removeresources("device", [zonemgr.Property("storage", suri)])
 def swap_volume(self, old_connection_info, new_connection_info,
-instance, mountpoint):
+instance, mountpoint, resize_to):
-"""Replace the disk attached to the instance."""
+"""Replace the disk attached to the instance.
+:param instance: nova.objects.instance.Instance
+:param resize_to: This parameter is used to indicate the new volume
+size when the new volume lager than old volume.
+And the units is Gigabyte.
+"""
 raise NotImplementedError()
 def attach_interface(self, instance, image_meta, vif):
-"""Attach an interface to the instance."""
+"""Attach an interface to the instance.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def detach_interface(self, instance, vif):
-"""Detach an interface from the instance."""
+"""Detach an interface from the instance.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def migrate_disk_and_power_off(self, context, instance, dest,
-instance_type, network_info,
+flavor, network_info,
-block_device_info=None):
+block_device_info=None,
-"""
+timeout=0, retry_interval=0):
-Transfers the disk of a running instance in multiple phases, turning
+"""Transfers the disk of a running instance in multiple phases, turning
 off the instance before the end.
-"""
-raise NotImplementedError()
+:param instance: nova.objects.instance.Instance
+:param timeout: time to wait for GuestOS to shutdown
-def live_snapshot(self, context, instance, image_id, update_task_state):
+:param retry_interval: How often to signal guest while
-"""
+waiting for it to shutdown
-Live-snapshots the specified instance (includes ram and proc state).
+"""
+raise NotImplementedError()
+def snapshot(self, context, instance, image_id, update_task_state):
+"""Snapshots the specified instance.
 :param context: security context
-:param instance: Instance object as returned by DB layer.
+:param instance: nova.objects.instance.Instance
-:param image_id: Reference to a pre-created image that will
-hold the snapshot.
-"""
-raise NotImplementedError()
-def snapshot(self, context, instance, image_id, update_task_state):
-"""
-Snapshots the specified instance.
-:param context: security context
-:param instance: Instance object as returned by DB layer.
 :param image_id: Reference to a pre-created image that will
 hold the snapshot.
 """
 # Get original base image info
 (base_service, base_id) = glance.get_remote_image_service(
 'name': snapshot['name'],
 'properties': {
 'image_location': 'snapshot',
 'image_state': 'available',
 'owner_id': instance['project_id'],
+'instance_uuid': instance['uuid'],
 }
 }
 # Match architecture, hypervisor_type and vm_mode properties to base
 # image.
 for prop in ['architecture', 'hypervisor_type', 'vm_mode']:
 fileutils.ensure_tree(snapshot_directory)
 snapshot_name = uuid.uuid4().hex
 with utils.tempdir(dir=snapshot_directory) as tmpdir:
 out_path = os.path.join(tmpdir, snapshot_name)
-# TODO(npower): archiveadm invocation needs --root-only arg
-# passed once it is available. Assume the instance contains
-# root pool only for now.
 zone_name = instance['name']
 utils.execute('/usr/sbin/archiveadm', 'create', '--root-only',
 '-z', zone_name, out_path)
 LOG.info(_("Snapshot extracted, beginning image upload"),
 instance=instance)
 try:
 # Upload the archive image to the image service
-update_task_state(task_state=task_states.IMAGE_UPLOADING,
+update_task_state(
-expected_state=
+task_state=task_states.IMAGE_UPLOADING,
-task_states.IMAGE_PENDING_UPLOAD)
+expected_state=task_states.IMAGE_PENDING_UPLOAD)
 with open(out_path, 'r') as image_file:
 snapshot_service.update(context,
 image_id,
 metadata,
 image_file)
 "'raw' as fallbacks."))
 finally:
 # Delete the snapshot image file source
 os.unlink(out_path)
+def post_interrupted_snapshot_cleanup(self, context, instance):
+"""Cleans up any resources left after an interrupted snapshot.
+:param context: security context
+:param instance: nova.objects.instance.Instance
+"""
+pass
 def finish_migration(self, context, migration, instance, disk_info,
 network_info, image_meta, resize_instance,
 block_device_info=None, power_on=True):
 """Completes a resize.
 :param context: the context for the migration/resize
 :param migration: the migrate/resize information
-:param instance: the instance being migrated/resized
+:param instance: nova.objects.instance.Instance being migrated/resized
 :param disk_info: the newly transferred disk information
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param image_meta: image object returned by nova.image.glance that
 defines the image from which this instance
 otherwise
 """
 raise NotImplementedError()
 def confirm_migration(self, migration, instance, network_info):
-"""Confirms a resize, destroying the source VM."""
+"""Confirms a resize, destroying the source VM.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def finish_revert_migration(self, instance, network_info,
+def finish_revert_migration(self, context, instance, network_info,
 block_device_info=None, power_on=True):
-"""
+"""Finish reverting a resize.
-Finish reverting a resize.
+:param context: the context for the finish_revert_migration
-:param instance: the instance being migrated/resized
+:param instance: nova.objects.instance.Instance being migrated/resized
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param block_device_info: instance volume block device info
 :param power_on: True if the instance should be powered on, False
 otherwise
 """
+raise NotImplementedError()
+def pause(self, instance):
+"""Pause the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def pause(self, instance):
+def unpause(self, instance):
-"""Pause the specified instance."""
+"""Unpause paused VM instance.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def unpause(self, instance):
+def suspend(self, instance):
-"""Unpause paused VM instance."""
+"""suspend the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def suspend(self, instance):
-"""suspend the specified instance."""
-# TODO(Vek): Need to pass context in for access to auth_token
-raise NotImplementedError()
 def resume(self, context, instance, network_info, block_device_info=None):
-"""
+"""resume the specified instance.
-resume the specified instance.
 :param context: the context for the resume
-:param instance: the instance being resumed
+:param instance: nova.objects.instance.Instance being resumed
 :param network_info:
 :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
 :param block_device_info: instance volume block device info
 """
 raise NotImplementedError()
 def resume_state_on_host_boot(self, context, instance, network_info,
 block_device_info=None):
-"""resume guest state when a host is booted."""
+"""resume guest state when a host is booted.
+:param instance: nova.objects.instance.Instance
+"""
 name = instance['name']
 zone = self._get_zone_by_name(name)
 if zone is None:
 raise exception.InstanceNotFound(instance_id=name)
 self._power_on(instance)
 def rescue(self, context, instance, network_info, image_meta,
 rescue_password):
-"""Rescue the specified instance."""
+"""Rescue the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
+raise NotImplementedError()
+def set_bootable(self, instance, is_bootable):
+"""Set the ability to power on/off an instance.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def unrescue(self, instance, network_info):
-"""Unrescue the specified instance."""
+"""Unrescue the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def power_off(self, instance):
+def power_off(self, instance, timeout=0, retry_interval=0):
-"""Power off the specified instance."""
+"""Power off the specified instance.
+:param instance: nova.objects.instance.Instance
+:param timeout: time to wait for GuestOS to shutdown
+:param retry_interval: How often to signal guest while
+waiting for it to shutdown
+"""
 self._power_off(instance, 'SOFT')
 def power_on(self, context, instance, network_info,
 block_device_info=None):
-"""Power on the specified instance."""
+"""Power on the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 self._power_on(instance)
 def soft_delete(self, instance):
-"""Soft delete the specified instance."""
+"""Soft delete the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def restore(self, instance):
-"""Restore the specified instance."""
+"""Restore the specified instance.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def _get_zpool_property(self, prop, zpool):
 """Get the value of property from the zpool."""
 try:
 resources['cpu_info'] = host_stats['cpu_info']
 resources['disk_available_least'] = host_stats['disk_available_least']
 resources['supported_instances'] = host_stats['supported_instances']
 return resources
-def pre_live_migration(self, ctxt, instance_ref, block_device_info,
+def pre_live_migration(self, context, instance, block_device_info,
 network_info, disk_info, migrate_data=None):
 """Prepare an instance for live migration
-:param ctxt: security context
+:param context: security context
-:param instance_ref: instance object that will be migrated
+:param instance: nova.objects.instance.Instance object
 :param block_device_info: instance block device information
 :param network_info: instance network information
 :param disk_info: instance disk information
 :param migrate_data: implementation specific data dict.
 """
 raise NotImplementedError()
-def live_migration(self, ctxt, instance_ref, dest,
+def live_migration(self, context, instance, dest,
 post_method, recover_method, block_migration=False,
 migrate_data=None):
 """Live migration of an instance to another host.
-:params ctxt: security context
+:param context: security context
-:params instance_ref:
+:param instance:
 nova.db.sqlalchemy.models.Instance object
 instance object that is migrated.
-:params dest: destination host
+:param dest: destination host
-:params post_method:
+:param post_method:
 post operation method.
-expected nova.compute.manager.post_live_migration.
+expected nova.compute.manager._post_live_migration.
-:params recover_method:
+:param recover_method:
 recovery method when any exception occurs.
-expected nova.compute.manager.recover_live_migration.
+expected nova.compute.manager._rollback_live_migration.
-:params block_migration: if true, migrate VM disk.
+:param block_migration: if true, migrate VM disk.
-:params migrate_data: implementation specific params.
+:param migrate_data: implementation specific params.
 """
 raise NotImplementedError()
-def post_live_migration(self, ctxt, instance_ref, block_device_info):
+def rollback_live_migration_at_destination(self, context, instance,
+network_info,
+block_device_info,
+destroy_disks=True,
+migrate_data=None):
+"""Clean up destination node after a failed live migration.
+:param context: security context
+:param instance: instance object that was being migrated
+:param network_info: instance network information
+:param block_device_info: instance block device information
+:param destroy_disks:
+if true, destroy disks at destination during cleanup
+:param migrate_data: implementation specific params
+"""
+raise NotImplementedError()
+def post_live_migration(self, context, instance, block_device_info,
+migrate_data=None):
 """Post operation of live migration at source host.
-:param ctxt: security contet
+:param context: security context
-:instance_ref: instance object that was migrated
+:instance: instance object that was migrated
 :block_device_info: instance block device information
+:param migrate_data: if not None, it is a dict which has data
 """
 pass
-def post_live_migration_at_destination(self, ctxt, instance_ref,
+def post_live_migration_at_source(self, context, instance, network_info):
+"""Unplug VIFs from networks at source.
+:param context: security context
+:param instance: instance object reference
+:param network_info: instance network information
+"""
+raise NotImplementedError(_("Hypervisor driver does not support "
+"post_live_migration_at_source method"))
+def post_live_migration_at_destination(self, context, instance,
 network_info,
 block_migration=False,
 block_device_info=None):
 """Post operation of live migration at destination host.
-:param ctxt: security context
+:param context: security context
-:param instance_ref: instance object that is migrated
+:param instance: instance object that is migrated
 :param network_info: instance network information
 :param block_migration: if true, post operation of block_migration.
 """
 raise NotImplementedError()
-def check_instance_shared_storage_local(self, ctxt, instance):
+def check_instance_shared_storage_local(self, context, instance):
 """Check if instance files located on shared storage.
 This runs check on the destination host, and then calls
 back to the source host to check the results.
-:param ctxt: security context
+:param context: security context
 :param instance: nova.db.sqlalchemy.models.Instance
 """
 raise NotImplementedError()
-def check_instance_shared_storage_remote(self, ctxt, data):
+def check_instance_shared_storage_remote(self, context, data):
 """Check if instance files located on shared storage.
 :param context: security context
 :param data: result of check_instance_shared_storage_local
 """
 raise NotImplementedError()
-def check_instance_shared_storage_cleanup(self, ctxt, data):
+def check_instance_shared_storage_cleanup(self, context, data):
 """Do cleanup on host after check_instance_shared_storage calls
-:param ctxt: security context
+:param context: security context
 :param data: result of check_instance_shared_storage_local
 """
 pass
-def check_can_live_migrate_destination(self, ctxt, instance_ref,
+def check_can_live_migrate_destination(self, context, instance,
 src_compute_info, dst_compute_info,
 block_migration=False,
 disk_over_commit=False):
 """Check if it is possible to execute live migration.
 This runs checks on the destination host, and then calls
 back to the source host to check the results.
-:param ctxt: security context
+:param context: security context
-:param instance_ref: nova.db.sqlalchemy.models.Instance
+:param instance: nova.db.sqlalchemy.models.Instance
 :param src_compute_info: Info about the sending machine
 :param dst_compute_info: Info about the receiving machine
 :param block_migration: if true, prepare for block migration
 :param disk_over_commit: if true, allow disk over commit
 :returns: a dict containing migration info (hypervisor-dependent)
 """
 raise NotImplementedError()
-def check_can_live_migrate_destination_cleanup(self, ctxt,
+def check_can_live_migrate_destination_cleanup(self, context,
 dest_check_data):
 """Do required cleanup on dest host after check_can_live_migrate calls
-:param ctxt: security context
+:param context: security context
 :param dest_check_data: result of check_can_live_migrate_destination
 """
 raise NotImplementedError()
-def check_can_live_migrate_source(self, ctxt, instance_ref,
+def check_can_live_migrate_source(self, context, instance,
 dest_check_data):
 """Check if it is possible to execute live migration.
 This checks if the live migration can succeed, based on the
 results from check_can_live_migrate_destination.
 :param context: security context
-:param instance_ref: nova.db.sqlalchemy.models.Instance
+:param instance: nova.db.sqlalchemy.models.Instance
 :param dest_check_data: result of check_can_live_migrate_destination
 :returns: a dict containing migration info (hypervisor-dependent)
+"""
+raise NotImplementedError()
+def get_instance_disk_info(self, instance_name,
+block_device_info=None):
+"""Retrieve information about actual disk sizes of an instance.
+:param instance_name:
+name of a nova instance as returned by list_instances()
+:param block_device_info:
+Optional; Can be used to filter out devices which are
+actually volumes.
+:return:
+json strings with below format::
+"[{'path':'disk',
+'type':'raw',
+'virt_disk_size':'10737418240',
+'backing_file':'backing_file',
+'disk_size':'83886080'
+'over_committed_disk_size':'10737418240'},
+...]"
 """
 raise NotImplementedError()
 def refresh_security_group_rules(self, security_group_id):
 """This method is called after a change to security groups.
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
+def refresh_instance_security_rules(self, instance):
+"""Refresh security group rules
+Gets called when an instance gets added to or removed from
+the security group the instance is a member of or if the
+group gains or loses a rule.
+"""
+raise NotImplementedError()
 def reset_network(self, instance):
 """reset networking for specified instance."""
 # TODO(Vek): Need to pass context in for access to auth_token
 pass
-def ensure_filtering_rules_for_instance(self, instance_ref, network_info):
+def ensure_filtering_rules_for_instance(self, instance, network_info):
 """Setting up filtering rules and waiting for its completion.
 To migrate an instance, filtering rules to hypervisors
 and firewalls are inevitable on destination host.
 ( Waiting only for filtering rules to hypervisor,
 Don't use thread for this method since migration should
 not be started when setting-up filtering rules operations
 are not completed.
-:params instance_ref: nova.db.sqlalchemy.models.Instance object
+:param instance: nova.objects.instance.Instance object
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
 def unfilter_instance(self, instance, network_info):
 """Stop filtering instance."""
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
-def set_admin_password(self, context, instance_id, new_pass=None):
+def set_admin_password(self, instance, new_pass):
-"""
+"""Set the root password on the specified instance.
-Set the root password on the specified instance.
+:param instance: nova.objects.instance.Instance
-The first parameter is an instance of nova.compute.service.Instance,
+:param new_password: the new password
-and so the instance is being specified as instance.name. The second
-parameter is the value of the new password.
 """
 raise NotImplementedError()
 def inject_file(self, instance, b64_path, b64_contents):
-"""
+"""Writes a file on the specified instance.
-Writes a file on the specified instance.
 The first parameter is an instance of nova.compute.service.Instance,
 and so the instance is being specified as instance.name. The second
 parameter is the base64-encoded path to which the file is to be
 written on the instance; the third is the contents of the file, also
 base64-encoded.
+NOTE(russellb) This method is deprecated and will be removed once it
+can be removed from nova.compute.manager.
 """
 # TODO(Vek): Need to pass context in for access to auth_token
 raise NotImplementedError()
 def change_instance_metadata(self, context, instance, diff):
-"""
+"""Applies a diff to the instance metadata.
-Applies a diff to the instance metadata.
 This is an optional driver method which is used to publish
 changes to the instance's metadata to the hypervisor.  If the
 hypervisor has no means of publishing the instance metadata to
 the instance, then this method should not be implemented.
+:param context: security context
+:param instance: nova.objects.instance.Instance
 """
 pass
 def inject_network_info(self, instance, nw_info):
 """inject network info for specified instance."""
 """Returns the result of calling "uptime" on the target host."""
 # TODO(Vek): Need to pass context in for access to auth_token
 return utils.execute('/usr/bin/uptime')[0]
 def plug_vifs(self, instance, network_info):
-"""Plug VIFs into networks."""
+"""Plug VIFs into networks.
+:param instance: nova.objects.instance.Instance
+"""
 # TODO(Vek): Need to pass context in for access to auth_token
 pass
 def unplug_vifs(self, instance, network_info):
-"""Unplug VIFs from networks."""
+"""Unplug VIFs from networks.
+:param instance: nova.objects.instance.Instance
+"""
 raise NotImplementedError()
 def get_host_stats(self, refresh=False):
 """Return currently known host stats.
 """
 if refresh or not self._host_stats:
 self._update_host_stats()
 return self._host_stats
+def get_host_cpu_stats(self):
+"""Get the currently known host CPU stats.
+:returns: a dict containing the CPU stat info, eg:
+| {'kernel': kern,
+|  'idle': idle,
+|  'user': user,
+|  'iowait': wait,
+|   'frequency': freq},
+where kern and user indicate the cumulative CPU time
+(nanoseconds) spent by kernel and user processes
+respectively, idle indicates the cumulative idle CPU time
+(nanoseconds), wait indicates the cumulative I/O wait CPU
+time (nanoseconds), since the host is booting up; freq
+indicates the current CPU frequency (MHz). All values are
+long integers.
+"""
+raise NotImplementedError()
 def block_stats(self, instance_name, disk_id):
-"""
+"""Return performance counters associated with the given disk_id on the
-Return performance counters associated with the given disk_id on the
 given instance_name.  These are returned as [rd_req, rd_bytes, wr_req,
 wr_bytes, errs], where rd indicates read, wr indicates write, req is
 the total number of I/O requests made, bytes is the total number of
 bytes transferred, and errs is the number of requests held up due to a
 full pipeline.
 Note that this function takes an instance ID.
 """
 raise NotImplementedError()
 def interface_stats(self, instance_name, iface_id):
-"""
+"""Return performance counters associated with the given iface_id
-Return performance counters associated with the given iface_id on the
+on the given instance_id.  These are returned as [rx_bytes, rx_packets,
-given instance_id.  These are returned as [rx_bytes, rx_packets,
 rx_errs, rx_drop, tx_bytes, tx_packets, tx_errs, tx_drop], where rx
 indicates receive, tx indicates transmit, bytes and packets indicate
 the total number of bytes or packets transferred, and errs and dropped
 is the total number of packets failed / dropped.
 unused.
 Note that this function takes an instance ID.
 """
 raise NotImplementedError()
+def deallocate_networks_on_reschedule(self, instance):
+"""Does the driver want networks deallocated on reschedule?"""
+return False
 def macs_for_instance(self, instance):
 """What MAC addresses must this instance have?
 Some hypervisors (such as bare metal) cannot do freeform virtualisation
 Note that the format of the return value is specific to Quantum
 client API.
 :return: None, or a set of DHCP options, eg:
-[{'opt_name': 'bootfile-name',
-'opt_value': '/tftpboot/path/to/config'},
+|    [{'opt_name': 'bootfile-name',
-{'opt_name': 'server-ip-address',
+|      'opt_value': '/tftpboot/path/to/config'},
-'opt_value': '1.2.3.4'},
+|     {'opt_name': 'server-ip-address',
-{'opt_name': 'tftp-server',
+|      'opt_value': '1.2.3.4'},
-'opt_value': '1.2.3.4'}
+|     {'opt_name': 'tftp-server',
-]
+|      'opt_value': '1.2.3.4'}
+|    ]
 """
 pass
 def manage_image_cache(self, context, all_instances):
-"""
+"""Manage the driver's local image cache.
-Manage the driver's local image cache.
 Some drivers chose to cache images for instances on disk. This method
 is an opportunity to do management of that cache which isn't directly
 related to other calls into the driver. The prime example is to clean
 the cache and remove images which are no longer of interest.
+:param instances: nova.objects.instance.InstanceList
 """
 pass
 def add_to_aggregate(self, context, aggregate, host, **kwargs):
 """Add a compute host to an aggregate."""
 """Get connector information for the instance for attaching to volumes.
 Connector information is a dictionary representing the ip of the
 machine that will be making the connection, the name of the iscsi
 initiator, the WWPN and WWNN values of the Fibre Channel initiator,
-and the hostname of the machine as follows:
+and the hostname of the machine as follows::
 {
 'ip': ip,
 'initiator': initiator,
 'wwnns': wwnns,
 'wwpns': wwpns,
 'host': hostname
 }
 """
 connector = {'ip': self.get_host_ip_addr(),
 'host': CONF.host}
 if not self._initiator:
 self._initiator = self._get_iscsi_initiator()
 return {}
 def instance_on_disk(self, instance):
 """Checks access of instance files on the host.
-:param instance: instance to lookup
+:param instance: nova.objects.instance.Instance to lookup
 Returns True if files of an instance with the supplied ID accessible on
 the host, False otherwise.
 .. note::
 compute manager to dispatch the event. This
 must only be invoked from a green thread.
 """
 if not self._compute_event_callback:
-LOG.debug(_("Discarding event %s") % str(event))
+LOG.debug("Discarding event %s", str(event))
 return
 if not isinstance(event, virtevent.Event):
 raise ValueError(
 _("Event must be an instance of nova.virt.event.Event"))
 try:
-LOG.debug(_("Emitting event %s") % str(event))
+LOG.debug("Emitting event %s", str(event))
 self._compute_event_callback(event)
 except Exception as ex:
 LOG.error(_("Exception dispatching event %(event)s: %(ex)s"),
 {'event': event, 'ex': ex})
 def delete_instance_files(self, instance):
 """Delete any lingering instance files for an instance.
+:param instance: nova.objects.instance.Instance
 :returns: True if the instance was deleted from disk, False otherwise.
 """
 return True
 @property
 def need_legacy_block_device_info(self):
 """Tell the caller if the driver requires legacy block device info.
-Tell the caller weather we expect the legacy format of block
+Tell the caller whether we expect the legacy format of block
 device info to be passed in to methods that expect it.
 """
 return True
 def volume_snapshot_create(self, context, instance, volume_id,
 create_info):
-"""
+"""Snapshots volumes attached to a specified instance.
-Snapshots volumes attached to a specified instance.
 :param context: request context
-:param instance: Instance object that has the volume attached
+:param instance: nova.objects.instance.Instance that has the volume
+attached
 :param volume_id: Volume to be snapshotted
 :param create_info: The data needed for nova to be able to attach
 to the volume.  This is the same data format returned by
 Cinder's initialize_connection() API call.  In the case of
 doing a snapshot, it is the image file Cinder expects to be
 """
 raise NotImplementedError()
 def volume_snapshot_delete(self, context, instance, volume_id,
 snapshot_id, delete_info):
-"""
+"""Snapshots volumes attached to a specified instance.
-Snapshots volumes attached to a specified instance.
 :param context: request context
-:param instance: Instance object that has the volume attached
+:param instance: nova.objects.instance.Instance that has the volume
+attached
 :param volume_id: Attached volume associated with the snapshot
 :param snapshot_id: The snapshot to delete.
 :param delete_info: Volume backend technology specific data needed to
 be able to complete the snapshot.  For example, in the case of
 qcow2 backed snapshots, this would include the file being
 def default_device_names_for_instance(self, instance, root_device_name,
 *block_device_lists):
 """Default the missing device names in the block device mapping."""
 raise NotImplementedError()
+def is_supported_fs_format(self, fs_type):
+"""Check whether the file format is supported by this driver
+:param fs_type: the file system type to be checked,
+the validate values are defined at disk API module.
+"""
+# NOTE(jichenjc): Return False here so that every hypervisor
+#                 need to define their supported file system
+#                 type and implement this function at their
+#                 virt layer.
+return False

branch	s11-update
changeset 4072	db0cec748ec0
parent 3809	eb8d6ce0657e
child 4569	e6bd6f2f307f