text: # Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
  # Copyright (c) 2012 VMware, Inc.
  # Copyright (c) 2011 Citrix Systems, Inc.
  # Copyright 2011 OpenStack Foundation
  #
  #    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.
  
  """
  Class for VM tasks like spawn, snapshot, suspend, resume etc.
  """
  
  import collections
  import os
  import time
  
  import decorator
  from oslo_concurrency import lockutils
  from oslo_config import cfg
  from oslo_log import log as logging
  from oslo_utils import excutils
  from oslo_utils import strutils
  from oslo_utils import units
  from oslo_utils import uuidutils
  from oslo_vmware import exceptions as vexc
  from oslo_vmware.objects import datastore as ds_obj
  from oslo_vmware import vim_util as vutil
  
  from nova.api.metadata import base as instance_metadata
  from nova import compute
  from nova.compute import power_state
  from nova.compute import task_states
  from nova.console import type as ctype
  from nova import context as nova_context
  from nova import exception
  from nova.i18n import _, _LE, _LI, _LW
  from nova import utils
  from nova import version
  from nova.virt import configdrive
  from nova.virt import diagnostics
  from nova.virt import driver
  from nova.virt import hardware
  from nova.virt.vmwareapi import constants
  from nova.virt.vmwareapi import ds_util
  from nova.virt.vmwareapi import error_util
  from nova.virt.vmwareapi import imagecache
  from nova.virt.vmwareapi import images
  from nova.virt.vmwareapi import vif as vmwarevif
  from nova.virt.vmwareapi import vim_util
  from nova.virt.vmwareapi import vm_util
  
  vmops_opts = [
      cfg.StrOpt('cache_prefix',
                 help='The prefix for Where cached images are stored. This is '
                      'NOT the full path - just a folder prefix. '
                      'This should only be used when a datastore cache should '
                      'be shared between compute nodes. Note: this should only '
                      'be used when the compute nodes have a shared file '
                      'system.'),
      ]
  
  CONF = cfg.CONF
  CONF.register_opts(vmops_opts, 'vmware')
  
  CONF.import_opt('image_cache_subdirectory_name', 'nova.virt.imagecache')
  CONF.import_opt('remove_unused_base_images', 'nova.virt.imagecache')
  CONF.import_opt('vnc_enabled', 'nova.vnc')
  CONF.import_opt('my_ip', 'nova.netconf')
  
  LOG = logging.getLogger(__name__)
  
  VMWARE_POWER_STATES = {
                     'poweredOff': power_state.SHUTDOWN,
                      'poweredOn': power_state.RUNNING,
                      'suspended': power_state.SUSPENDED}
  
  RESIZE_TOTAL_STEPS = 6
  
  DcInfo = collections.namedtuple('DcInfo',
                                  ['ref', 'name', 'vmFolder'])
  
  
  class VirtualMachineInstanceConfigInfo(object):
      """Parameters needed to create and configure a new instance."""
  
      def __init__(self, instance, image_info, datastore, dc_info, image_cache):
  
          # Some methods called during spawn take the instance parameter purely
          # for logging purposes.
          # TODO(vui) Clean them up, so we no longer need to keep this variable
          self.instance = instance
  
          self.ii = image_info
          self.root_gb = instance.root_gb
          self.datastore = datastore
          self.dc_info = dc_info
          self._image_cache = image_cache
  
      @property
      def cache_image_folder(self):
          if self.ii.image_id is None:
              return
          return self._image_cache.get_image_cache_folder(
                     self.datastore, self.ii.image_id)
  
      @property
      def cache_image_path(self):
          if self.ii.image_id is None:
              return
          cached_image_file_name = "%s.%s" % (self.ii.image_id,
                                              self.ii.file_type)
          return self.cache_image_folder.join(cached_image_file_name)
  
  
  # Note(vui): See https://bugs.launchpad.net/nova/+bug/1363349
  # for cases where mocking time.sleep() can have unintended effects on code
  # not under test. For now, unblock the affected test cases by providing
  # a wrapper function to work around needing to mock time.sleep()
  def _time_sleep_wrapper(delay):
      time.sleep(delay)
  
  
  @decorator.decorator
  def retry_if_task_in_progress(f, *args, **kwargs):
      retries = max(CONF.vmware.api_retry_count, 1)
      delay = 1
      for attempt in range(1, retries + 1):
          if attempt != 1:
              _time_sleep_wrapper(delay)
              delay = min(2 * delay, 60)
          try:
              f(*args, **kwargs)
              return
          except vexc.TaskInProgress:
              pass
  
  
  class VMwareVMOps(object):
      """Management class for VM-related tasks."""
  
      def __init__(self, session, virtapi, volumeops, cluster=None,
                   datastore_regex=None):
          """Initializer."""
          self.compute_api = compute.API()
          self._session = session
          self._virtapi = virtapi
          self._volumeops = volumeops
          self._cluster = cluster
          self._root_resource_pool = vm_util.get_res_pool_ref(self._session,
                                                              self._cluster)
          self._datastore_regex = datastore_regex
          self._base_folder = self._get_base_folder()
          self._tmp_folder = 'vmware_temp'
          self._datastore_dc_mapping = {}
          self._datastore_browser_mapping = {}
          self._imagecache = imagecache.ImageCacheManager(self._session,
                                                          self._base_folder)
  
      def _get_base_folder(self):
          # Enable more than one compute node to run on the same host
          if CONF.vmware.cache_prefix:
              base_folder = '%s%s' % (CONF.vmware.cache_prefix,
                                      CONF.image_cache_subdirectory_name)
          # Ensure that the base folder is unique per compute node
          elif CONF.remove_unused_base_images:
              base_folder = '%s%s' % (CONF.my_ip,
                                      CONF.image_cache_subdirectory_name)
          else:
              # Aging disable ensures backward compatibility
              base_folder = CONF.image_cache_subdirectory_name
          return base_folder
  
      def _extend_virtual_disk(self, instance, requested_size, name, dc_ref):
          service_content = self._session.vim.service_content
          LOG.debug("Extending root virtual disk to %s", requested_size,
                    instance=instance)
          vmdk_extend_task = self._session._call_method(
                  self._session.vim,
                  "ExtendVirtualDisk_Task",
                  service_content.virtualDiskManager,
                  name=name,
                  datacenter=dc_ref,
                  newCapacityKb=requested_size,
                  eagerZero=False)
          try:
              self._session._wait_for_task(vmdk_extend_task)
          except Exception as e:
              with excutils.save_and_reraise_exception():
                  LOG.error(_LE('Extending virtual disk failed with error: %s'),
                            e, instance=instance)
                  # Clean up files created during the extend operation
                  files = [name.replace(".vmdk", "-flat.vmdk"), name]
                  for file in files:
                      ds_path = ds_obj.DatastorePath.parse(file)
                      self._delete_datastore_file(ds_path, dc_ref)
  
          LOG.debug("Extended root virtual disk", instance=instance)
  
      def _delete_datastore_file(self, datastore_path, dc_ref):
          try:
              ds_util.file_delete(self._session, datastore_path, dc_ref)
          except (vexc.CannotDeleteFileException,
                  vexc.FileFaultException,
                  vexc.FileLockedException,
                  vexc.FileNotFoundException):
              LOG.debug("Unable to delete %(ds)s. There may be more than "
                        "one process or thread trying to delete the file",
                        {'ds': datastore_path},
                        exc_info=True)
  
      def _extend_if_required(self, dc_info, image_info, instance,
                              root_vmdk_path):
          """Increase the size of the root vmdk if necessary."""
          if instance.root_gb * units.Gi > image_info.file_size:
              size_in_kb = instance.root_gb * units.Mi
              self._extend_virtual_disk(instance, size_in_kb,
                                        root_vmdk_path, dc_info.ref)
  
      def _configure_config_drive(self, instance, vm_ref, dc_info, datastore,
                                  injected_files, admin_password):
          session_vim = self._session.vim
          cookies = session_vim.client.options.transport.cookiejar
  
          uploaded_iso_path = self._create_config_drive(instance,
                                                        injected_files,
                                                        admin_password,
                                                        datastore.name,
                                                        dc_info.name,
                                                        instance.uuid,
                                                        cookies)
          uploaded_iso_path = datastore.build_path(uploaded_iso_path)
          self._attach_cdrom_to_vm(
              vm_ref, instance,
              datastore.ref,
              str(uploaded_iso_path))
  
      def _get_instance_metadata(self, context, instance):
          flavor = instance.flavor
          return ('name:%s\n'
                  'userid:%s\n'
                  'username:%s\n'
                  'projectid:%s\n'
                  'projectname:%s\n'
                  'flavor:name:%s\n'
                  'flavor:memory_mb:%s\n'
                  'flavor:vcpus:%s\n'
                  'flavor:ephemeral_gb:%s\n'
                  'flavor:root_gb:%s\n'
                  'flavor:swap:%s\n'
                  'imageid:%s\n'
                  'package:%s\n') % (instance.display_name,
                                     context.user_id,
                                     context.user_name,
                                     context.project_id,
                                     context.project_name,
                                     flavor.name,
                                     flavor.memory_mb,
                                     flavor.vcpus,
                                     flavor.ephemeral_gb,
                                     flavor.root_gb,
                                     flavor.swap,
                                     instance.image_ref,
                                     version.version_string_with_package())
  
      def build_virtual_machine(self, instance, image_info,
                                dc_info, datastore, network_info, extra_specs,
                                metadata):
          vif_infos = vmwarevif.get_vif_info(self._session,
                                             self._cluster,
                                             utils.is_neutron(),
                                             image_info.vif_model,
                                             network_info)
  
          if extra_specs.storage_policy:
              profile_spec = vm_util.get_storage_profile_spec(
                  self._session, extra_specs.storage_policy)
          else:
              profile_spec = None
          # Get the create vm config spec
          client_factory = self._session.vim.client.factory
          config_spec = vm_util.get_vm_create_spec(client_factory,
                                                   instance,
                                                   datastore.name,
                                                   vif_infos,
                                                   extra_specs,
                                                   image_info.os_type,
                                                   profile_spec=profile_spec,
                                                   metadata=metadata)
          # Create the VM
          vm_ref = vm_util.create_vm(self._session, instance, dc_info.vmFolder,
                                     config_spec, self._root_resource_pool)
          return vm_ref
  
      def _get_extra_specs(self, flavor):
          extra_specs = vm_util.ExtraSpecs()
          for (key, type) in (('cpu_limit', int),
                              ('cpu_reservation', int),
                              ('cpu_shares_level', str),
                              ('cpu_shares_share', int)):
              value = flavor.extra_specs.get('quota:' + key)
              if value:
                  setattr(extra_specs.cpu_limits, key, type(value))
          extra_specs.cpu_limits.validate()
          hw_version = flavor.extra_specs.get('vmware:hw_version')
          extra_specs.hw_version = hw_version
          if CONF.vmware.pbm_enabled:
              storage_policy = flavor.extra_specs.get('vmware:storage_policy',
                      CONF.vmware.pbm_default_policy)
              extra_specs.storage_policy = storage_policy
          return extra_specs
  
      def _fetch_image_as_file(self, context, vi, image_ds_loc):
          """Download image as an individual file to host via HTTP PUT."""
          session = self._session
          session_vim = session.vim
          cookies = session_vim.client.options.transport.cookiejar
  
          LOG.debug("Downloading image file data %(image_id)s to "
                    "%(file_path)s on the data store "
                    "%(datastore_name)s",
                    {'image_id': vi.ii.image_id,
                     'file_path': image_ds_loc,
                     'datastore_name': vi.datastore.name},
                    instance=vi.instance)
  
          images.fetch_image(
              context,
              vi.instance,
              session._host,
              session._port,
              vi.dc_info.name,
              vi.datastore.name,
              image_ds_loc.rel_path,
              cookies=cookies)
  
      def _fetch_image_as_vapp(self, context, vi, image_ds_loc):
          """Download stream optimized image to host as a vApp."""
  
          # The directory of the imported disk is the unique name
          # of the VM use to import it with.
          vm_name = image_ds_loc.parent.basename
  
          LOG.debug("Downloading stream optimized image %(image_id)s to "
                    "%(file_path)s on the data store "
                    "%(datastore_name)s as vApp",
                    {'image_id': vi.ii.image_id,
                     'file_path': image_ds_loc,
                     'datastore_name': vi.datastore.name},
                    instance=vi.instance)
  
          images.fetch_image_stream_optimized(
              context,
              vi.instance,
              self._session,
              vm_name,
              vi.datastore.name,
              vi.dc_info.vmFolder,
              self._root_resource_pool)
  
      def _fetch_image_as_ova(self, context, vi, image_ds_loc):
          """Download root disk of an OVA image as streamOptimized."""
  
          # The directory of the imported disk is the unique name
          # of the VM use to import it with.
          vm_name = image_ds_loc.parent.basename
  
          images.fetch_image_ova(context,
                                 vi.instance,
                                 self._session,
                                 vm_name,
                                 vi.datastore.name,
                                 vi.dc_info.vmFolder,
                                 self._root_resource_pool)
  
      def _prepare_sparse_image(self, vi):
          tmp_dir_loc = vi.datastore.build_path(
                  self._tmp_folder, uuidutils.generate_uuid())
          tmp_image_ds_loc = tmp_dir_loc.join(
                  vi.ii.image_id, "tmp-sparse.vmdk")
          return tmp_dir_loc, tmp_image_ds_loc
  
      def _prepare_flat_image(self, vi):
          tmp_dir_loc = vi.datastore.build_path(
                  self._tmp_folder, uuidutils.generate_uuid())
          tmp_image_ds_loc = tmp_dir_loc.join(
                  vi.ii.image_id, vi.cache_image_path.basename)
          ds_util.mkdir(self._session, tmp_image_ds_loc.parent, vi.dc_info.ref)
          vm_util.create_virtual_disk(
                  self._session, vi.dc_info.ref,
                  vi.ii.adapter_type,
                  vi.ii.disk_type,
                  str(tmp_image_ds_loc),
                  vi.ii.file_size_in_kb)
          flat_vmdk_name = vi.cache_image_path.basename.replace('.vmdk',
                                                                '-flat.vmdk')
          flat_vmdk_ds_loc = tmp_dir_loc.join(vi.ii.image_id, flat_vmdk_name)
          self._delete_datastore_file(str(flat_vmdk_ds_loc), vi.dc_info.ref)
          return tmp_dir_loc, flat_vmdk_ds_loc
  
      def _prepare_stream_optimized_image(self, vi):
          vm_name = "%s_%s" % (constants.IMAGE_VM_PREFIX,
                               uuidutils.generate_uuid())
          tmp_dir_loc = vi.datastore.build_path(vm_name)
          tmp_image_ds_loc = tmp_dir_loc.join("%s.vmdk" % tmp_dir_loc.basename)
          return tmp_dir_loc, tmp_image_ds_loc
  
      def _prepare_iso_image(self, vi):
          tmp_dir_loc = vi.datastore.build_path(
                  self._tmp_folder, uuidutils.generate_uuid())
          tmp_image_ds_loc = tmp_dir_loc.join(
                  vi.ii.image_id, vi.cache_image_path.basename)
          return tmp_dir_loc, tmp_image_ds_loc
  
      def _move_to_cache(self, dc_ref, src_folder_ds_path, dst_folder_ds_path):
          try:
              ds_util.file_move(self._session, dc_ref,
                                src_folder_ds_path, dst_folder_ds_path)
          except vexc.FileAlreadyExistsException:
              # Folder move has failed. This may be due to the fact that a
              # process or thread has already completed the operation.
              # Since image caching is synchronized, this can only happen
              # due to action external to the process.
              # In the event of a FileAlreadyExists we continue,
              # all other exceptions will be raised.
              LOG.warning(_LW("Destination %s already exists! Concurrent moves "
                              "can lead to unexpected results."),
                          dst_folder_ds_path)
  
      def _cache_sparse_image(self, vi, tmp_image_ds_loc):
          tmp_dir_loc = tmp_image_ds_loc.parent.parent
          converted_image_ds_loc = tmp_dir_loc.join(
                  vi.ii.image_id, vi.cache_image_path.basename)
          # converts fetched image to preallocated disk
          vm_util.copy_virtual_disk(
                  self._session,
                  vi.dc_info.ref,
                  str(tmp_image_ds_loc),
                  str(converted_image_ds_loc))
  
          self._delete_datastore_file(str(tmp_image_ds_loc), vi.dc_info.ref)
  
          self._move_to_cache(vi.dc_info.ref,
                              tmp_image_ds_loc.parent,
                              vi.cache_image_folder)
  
      def _cache_flat_image(self, vi, tmp_image_ds_loc):
          self._move_to_cache(vi.dc_info.ref,
                              tmp_image_ds_loc.parent,
                              vi.cache_image_folder)
  
      def _cache_stream_optimized_image(self, vi, tmp_image_ds_loc):
          dst_path = vi.cache_image_folder.join("%s.vmdk" % vi.ii.image_id)
          ds_util.mkdir(self._session, vi.cache_image_folder, vi.dc_info.ref)
          try:
              ds_util.disk_move(self._session, vi.dc_info.ref,
                                tmp_image_ds_loc, dst_path)
          except vexc.FileAlreadyExistsException:
              pass
  
      def _cache_iso_image(self, vi, tmp_image_ds_loc):
          self._move_to_cache(vi.dc_info.ref,
                              tmp_image_ds_loc.parent,
                              vi.cache_image_folder)
  
      def _get_vm_config_info(self, instance, image_info,
                              storage_policy=None):
          """Captures all relevant information from the spawn parameters."""
  
          if (instance.root_gb != 0 and
                  image_info.file_size > instance.root_gb * units.Gi):
              reason = _("Image disk size greater than requested disk size")
              raise exception.InstanceUnacceptable(instance_id=instance.uuid,
                                                   reason=reason)
          allowed_ds_types = ds_util.get_allowed_datastore_types(
              image_info.disk_type)
          datastore = ds_util.get_datastore(self._session,
                                            self._cluster,
                                            self._datastore_regex,
                                            storage_policy,
                                            allowed_ds_types)
          dc_info = self.get_datacenter_ref_and_name(datastore.ref)
  
          return VirtualMachineInstanceConfigInfo(instance,
                                                  image_info,
                                                  datastore,
                                                  dc_info,
                                                  self._imagecache)
  
      def _get_image_callbacks(self, vi):
          disk_type = vi.ii.disk_type
  
          if vi.ii.is_ova:
              image_fetch = self._fetch_image_as_ova
          elif disk_type == constants.DISK_TYPE_STREAM_OPTIMIZED:
              image_fetch = self._fetch_image_as_vapp
          else:
              image_fetch = self._fetch_image_as_file
  
          if vi.ii.is_iso:
              image_prepare = self._prepare_iso_image
              image_cache = self._cache_iso_image
          elif disk_type == constants.DISK_TYPE_SPARSE:
              image_prepare = self._prepare_sparse_image
              image_cache = self._cache_sparse_image
          elif disk_type == constants.DISK_TYPE_STREAM_OPTIMIZED:
              image_prepare = self._prepare_stream_optimized_image
              image_cache = self._cache_stream_optimized_image
          elif disk_type in constants.SUPPORTED_FLAT_VARIANTS:
              image_prepare = self._prepare_flat_image
              image_cache = self._cache_flat_image
          else:
              reason = _("disk type '%s' not supported") % disk_type
              raise exception.InvalidDiskInfo(reason=reason)
          return image_prepare, image_fetch, image_cache
  
      def _fetch_image_if_missing(self, context, vi):
          image_prepare, image_fetch, image_cache = self._get_image_callbacks(vi)
          LOG.debug("Processing image %s", vi.ii.image_id, instance=vi.instance)
  
          with lockutils.lock(str(vi.cache_image_path),
                              lock_file_prefix='nova-vmware-fetch_image'):
              self.check_cache_folder(vi.datastore.name, vi.datastore.ref)
              ds_browser = self._get_ds_browser(vi.datastore.ref)
              if not ds_util.file_exists(self._session, ds_browser,
                                         vi.cache_image_folder,
                                         vi.cache_image_path.basename):
                  LOG.debug("Preparing fetch location", instance=vi.instance)
                  tmp_dir_loc, tmp_image_ds_loc = image_prepare(vi)
                  LOG.debug("Fetch image to %s", tmp_image_ds_loc,
                            instance=vi.instance)
                  image_fetch(context, vi, tmp_image_ds_loc)
                  LOG.debug("Caching image", instance=vi.instance)
                  image_cache(vi, tmp_image_ds_loc)
                  LOG.debug("Cleaning up location %s", str(tmp_dir_loc),
                            instance=vi.instance)
                  self._delete_datastore_file(str(tmp_dir_loc), vi.dc_info.ref)
  
      def _create_and_attach_ephemeral_disk(self, instance, vm_ref, dc_info,
                                            size, adapter_type, path):
          disk_type = constants.DISK_TYPE_THIN
          vm_util.create_virtual_disk(
                  self._session, dc_info.ref,
                  adapter_type,
                  disk_type,
                  path,
                  size)
  
          self._volumeops.attach_disk_to_vm(
                  vm_ref, instance,
                  adapter_type, disk_type,
                  path, size, False)
  
      def _create_ephemeral(self, bdi, instance, vm_ref, dc_info,
                            datastore, folder, adapter_type):
          ephemerals = None
          if bdi is not None:
              ephemerals = driver.block_device_info_get_ephemerals(bdi)
              for idx, eph in enumerate(ephemerals):
                  size = eph['size'] * units.Mi
                  at = eph.get('disk_bus', adapter_type)
                  filename = vm_util.get_ephemeral_name(idx)
                  path = str(ds_obj.DatastorePath(datastore.name, folder,
                                                  filename))
                  self._create_and_attach_ephemeral_disk(instance, vm_ref,
                                                         dc_info, size,
                                                         at, path)
          # There may be block devices defined but no ephemerals. In this case
          # we need to allocate a ephemeral disk if required
          if not ephemerals and instance.ephemeral_gb:
              size = instance.ephemeral_gb * units.Mi
              filename = vm_util.get_ephemeral_name(0)
              path = str(ds_obj.DatastorePath(datastore.name, folder,
                                              filename))
              self._create_and_attach_ephemeral_disk(instance, vm_ref,
                                                     dc_info, size,
                                                     adapter_type, path)
  
      def spawn(self, context, instance, image_meta, injected_files,
                admin_password, network_info, block_device_info=None):
  
          client_factory = self._session.vim.client.factory
          image_info = images.VMwareImage.from_image(instance.image_ref,
                                                     image_meta)
          extra_specs = self._get_extra_specs(instance.flavor)
  
          vi = self._get_vm_config_info(instance, image_info,
                                        extra_specs.storage_policy)
  
          metadata = self._get_instance_metadata(context, instance)
          # Creates the virtual machine. The virtual machine reference returned
          # is unique within Virtual Center.
          vm_ref = self.build_virtual_machine(instance,
                                              image_info,
                                              vi.dc_info,
                                              vi.datastore,
                                              network_info,
                                              extra_specs,
                                              metadata)
  
          # Cache the vm_ref. This saves a remote call to the VC. This uses the
          # instance uuid.
          vm_util.vm_ref_cache_update(instance.uuid, vm_ref)
  
          # Set the machine.id parameter of the instance to inject
          # the NIC configuration inside the VM
          if CONF.flat_injected:
              self._set_machine_id(client_factory, instance, network_info,
                                  vm_ref=vm_ref)
  
          # Set the vnc configuration of the instance, vnc port starts from 5900
          if CONF.vnc_enabled:
              self._get_and_set_vnc_config(client_factory, instance, vm_ref)
  
          block_device_mapping = []
          if block_device_info is not None:
              block_device_mapping = driver.block_device_info_get_mapping(
                  block_device_info)
  
          if instance.image_ref:
              self._imagecache.enlist_image(
                      image_info.image_id, vi.datastore, vi.dc_info.ref)
              self._fetch_image_if_missing(context, vi)
  
              if image_info.is_iso:
                  self._use_iso_image(vm_ref, vi)
              elif image_info.linked_clone:
                  self._use_disk_image_as_linked_clone(vm_ref, vi)
              else:
                  self._use_disk_image_as_full_clone(vm_ref, vi)
  
          if len(block_device_mapping) > 0:
              msg = "Block device information present: %s" % block_device_info
              # NOTE(mriedem): block_device_info can contain an auth_password
              # so we have to scrub the message before logging it.
              LOG.debug(strutils.mask_password(msg), instance=instance)
  
              # Before attempting to attach any volume, make sure the
              # block_device_mapping (i.e. disk_bus) is valid
              self._is_bdm_valid(block_device_mapping)
  
              for disk in block_device_mapping:
                  connection_info = disk['connection_info']
                  adapter_type = disk.get('disk_bus') or vi.ii.adapter_type
  
                  # TODO(hartsocks): instance is unnecessary, remove it
                  # we still use instance in many locations for no other purpose
                  # than logging, can we simplify this?
                  if disk.get('boot_index') == 0:
                      self._volumeops.attach_root_volume(connection_info,
                          instance, vi.datastore.ref, adapter_type)
                  else:
                      self._volumeops.attach_volume(connection_info,
                          instance, adapter_type)
  
          # Create ephemeral disks
          self._create_ephemeral(block_device_info, instance, vm_ref,
                                 vi.dc_info, vi.datastore, instance.uuid,
                                 vi.ii.adapter_type)
  
          if configdrive.required_by(instance):
              self._configure_config_drive(
                      instance, vm_ref, vi.dc_info, vi.datastore,
                      injected_files, admin_password)
  
          vm_util.power_on_instance(self._session, instance, vm_ref=vm_ref)
  
      def _is_bdm_valid(self, block_device_mapping):
          """Checks if the block device mapping is valid."""
          valid_bus = (constants.DEFAULT_ADAPTER_TYPE,
                       constants.ADAPTER_TYPE_BUSLOGIC,
                       constants.ADAPTER_TYPE_IDE,
                       constants.ADAPTER_TYPE_LSILOGICSAS,
                       constants.ADAPTER_TYPE_PARAVIRTUAL)
  
          for disk in block_device_mapping:
              adapter_type = disk.get('disk_bus')
              if (adapter_type is not None and adapter_type not in valid_bus):
                  raise exception.UnsupportedHardware(model=adapter_type,
                                                      virt="vmware")
  
      def _create_config_drive(self, instance, injected_files, admin_password,
                               data_store_name, dc_name, upload_folder, cookies):
          if CONF.config_drive_format != 'iso9660':
              reason = (_('Invalid config_drive_format "%s"') %
                        CONF.config_drive_format)
              raise exception.InstancePowerOnFailure(reason=reason)
  
          LOG.info(_LI('Using config drive for instance'), instance=instance)
          extra_md = {}
          if admin_password:
              extra_md['admin_pass'] = admin_password
  
          inst_md = instance_metadata.InstanceMetadata(instance,
                                                       content=injected_files,
                                                       extra_md=extra_md)
          try:
              with configdrive.ConfigDriveBuilder(instance_md=inst_md) as cdb:
                  with utils.tempdir() as tmp_path:
                      tmp_file = os.path.join(tmp_path, 'configdrive.iso')
                      cdb.make_drive(tmp_file)
                      upload_iso_path = "%s/configdrive.iso" % (
                          upload_folder)
                      images.upload_iso_to_datastore(
                          tmp_file, instance,
                          host=self._session._host,
                          port=self._session._port,
                          data_center_name=dc_name,
                          datastore_name=data_store_name,
                          cookies=cookies,
                          file_path=upload_iso_path)
                      return upload_iso_path
          except Exception as e:
              with excutils.save_and_reraise_exception():
                  LOG.error(_LE('Creating config drive failed with error: %s'),
                            e, instance=instance)
  
      def _attach_cdrom_to_vm(self, vm_ref, instance,
                              datastore, file_path):
          """Attach cdrom to VM by reconfiguration."""
          client_factory = self._session.vim.client.factory
          devices = self._session._call_method(vim_util,
                                      "get_dynamic_property", vm_ref,
                                      "VirtualMachine", "config.hardware.device")
          (controller_key, unit_number,
           controller_spec) = vm_util.allocate_controller_key_and_unit_number(
                                                                client_factory,
                                                                devices,
                                                                'ide')
          cdrom_attach_config_spec = vm_util.get_cdrom_attach_config_spec(
                                      client_factory, datastore, file_path,
                                      controller_key, unit_number)
          if controller_spec:
              cdrom_attach_config_spec.deviceChange.append(controller_spec)
  
          LOG.debug("Reconfiguring VM instance to attach cdrom %s",
                    file_path, instance=instance)
          vm_util.reconfigure_vm(self._session, vm_ref, cdrom_attach_config_spec)
          LOG.debug("Reconfigured VM instance to attach cdrom %s",
                    file_path, instance=instance)
  
      def _create_vm_snapshot(self, instance, vm_ref):
          LOG.debug("Creating Snapshot of the VM instance", instance=instance)
          snapshot_task = self._session._call_method(
                      self._session.vim,
                      "CreateSnapshot_Task", vm_ref,
                      name="%s-snapshot" % instance.uuid,
                      description="Taking Snapshot of the VM",
                      memory=False,
                      quiesce=True)
          self._session._wait_for_task(snapshot_task)
          LOG.debug("Created Snapshot of the VM instance", instance=instance)
          task_info = self._session._call_method(vim_util,
                                                 "get_dynamic_property",
                                                 snapshot_task, "Task", "info")
          snapshot = task_info.result
          return snapshot
  
      @retry_if_task_in_progress
      def _delete_vm_snapshot(self, instance, vm_ref, snapshot):
          LOG.debug("Deleting Snapshot of the VM instance", instance=instance)
          delete_snapshot_task = self._session._call_method(
                      self._session.vim,
                      "RemoveSnapshot_Task", snapshot,
                      removeChildren=False, consolidate=True)
          self._session._wait_for_task(delete_snapshot_task)
          LOG.debug("Deleted Snapshot of the VM instance", instance=instance)
  
      def _create_linked_clone_from_snapshot(self, instance,
                                             vm_ref, snapshot_ref, dc_info):
          """Create linked clone VM to be deployed to same ds as source VM
          """
          client_factory = self._session.vim.client.factory
          rel_spec = vm_util.relocate_vm_spec(
                  client_factory,
                  datastore=None,
                  host=None,
                  disk_move_type="createNewChildDiskBacking")
          clone_spec = vm_util.clone_vm_spec(client_factory, rel_spec,
                  power_on=False, snapshot=snapshot_ref, template=True)
          vm_name = "%s_%s" % (constants.SNAPSHOT_VM_PREFIX,
                               uuidutils.generate_uuid())
  
          LOG.debug("Creating linked-clone VM from snapshot", instance=instance)
          vm_clone_task = self._session._call_method(
                                  self._session.vim,
                                  "CloneVM_Task",
                                  vm_ref,
                                  folder=dc_info.vmFolder,
                                  name=vm_name,
                                  spec=clone_spec)
          self._session._wait_for_task(vm_clone_task)
          LOG.info(_LI("Created linked-clone VM from snapshot"),
                   instance=instance)
          task_info = self._session._call_method(vim_util,
                                                 "get_dynamic_property",
                                                 vm_clone_task, "Task", "info")
          return task_info.result
  
      def snapshot(self, context, instance, image_id, update_task_state):
          """Create snapshot from a running VM instance.
  
          Steps followed are:
  
          1. Get the name of the vmdk file which the VM points to right now.
             Can be a chain of snapshots, so we need to know the last in the
             chain.
          2. Create the snapshot. A new vmdk is created which the VM points to
             now. The earlier vmdk becomes read-only.
          3. Creates a linked clone VM from the snapshot
          4. Exports the disk in the link clone VM as a streamOptimized disk.
          5. Delete the linked clone VM
          6. Deletes the snapshot in original instance.
          """
          vm_ref = vm_util.get_vm_ref(self._session, instance)
  
          def _get_vm_and_vmdk_attribs():
              # Get the vmdk info that the VM is pointing to
              vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                                instance.uuid)
              if not vmdk.path:
                  LOG.debug("No root disk defined. Unable to snapshot.",
                            instance=instance)
                  raise error_util.NoRootDiskDefined()
  
              lst_properties = ["datastore", "summary.config.guestId"]
              props = self._session._call_method(vim_util,
                                                 "get_object_properties",
                                                 None, vm_ref, "VirtualMachine",
                                                 lst_properties)
              query = vm_util.get_values_from_object_properties(self._session,
                                                                props)
              os_type = query['summary.config.guestId']
              datastores = query['datastore']
              return (vmdk, datastores, os_type)
  
          vmdk, datastores, os_type = _get_vm_and_vmdk_attribs()
          ds_ref = datastores.ManagedObjectReference[0]
          dc_info = self.get_datacenter_ref_and_name(ds_ref)
  
          update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD)
  
          # TODO(vui): convert to creating plain vm clone and uploading from it
          # instead of using live vm snapshot.
          snapshot_ref = self._create_vm_snapshot(instance, vm_ref)
  
          update_task_state(task_state=task_states.IMAGE_UPLOADING,
                            expected_state=task_states.IMAGE_PENDING_UPLOAD)
          snapshot_vm_ref = None
  
          try:
              # Create a temporary VM (linked clone from snapshot), then export
              # the VM's root disk to glance via HttpNfc API
              snapshot_vm_ref = self._create_linked_clone_from_snapshot(
                  instance, vm_ref, snapshot_ref, dc_info)
              images.upload_image_stream_optimized(
                  context, image_id, instance, self._session, vm=snapshot_vm_ref,
                  vmdk_size=vmdk.capacity_in_bytes)
          finally:
              if snapshot_vm_ref:
                  vm_util.destroy_vm(self._session, instance, snapshot_vm_ref)
              # Deleting the snapshot after destroying the temporary VM created
              # based on it allows the instance vm's disks to be consolidated.
              # TODO(vui) Add handling for when vmdk volume is attached.
              self._delete_vm_snapshot(instance, vm_ref, snapshot_ref)
  
      def reboot(self, instance, network_info, reboot_type="SOFT"):
          """Reboot a VM instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          lst_properties = ["summary.guest.toolsStatus", "runtime.powerState",
                            "summary.guest.toolsRunningStatus"]
          props = self._session._call_method(vim_util, "get_object_properties",
                             None, vm_ref, "VirtualMachine",
                             lst_properties)
          query = vm_util.get_values_from_object_properties(self._session, props)
          pwr_state = query['runtime.powerState']
          tools_status = query['summary.guest.toolsStatus']
          tools_running_status = query['summary.guest.toolsRunningStatus']
  
          # Raise an exception if the VM is not powered On.
          if pwr_state not in ["poweredOn"]:
              reason = _("instance is not powered on")
              raise exception.InstanceRebootFailure(reason=reason)
  
          # If latest vmware tools are installed in the VM, and that the tools
          # are running, then only do a guest reboot. Otherwise do a hard reset.
          if (tools_status == "toolsOk" and
                  tools_running_status == "guestToolsRunning" and
                  reboot_type == "SOFT"):
              LOG.debug("Rebooting guest OS of VM", instance=instance)
              self._session._call_method(self._session.vim, "RebootGuest",
                                         vm_ref)
              LOG.debug("Rebooted guest OS of VM", instance=instance)
          else:
              LOG.debug("Doing hard reboot of VM", instance=instance)
              reset_task = self._session._call_method(self._session.vim,
                                                      "ResetVM_Task", vm_ref)
              self._session._wait_for_task(reset_task)
              LOG.debug("Did hard reboot of VM", instance=instance)
  
      def _destroy_instance(self, instance, destroy_disks=True):
          # Destroy a VM instance
          try:
              vm_ref = vm_util.get_vm_ref(self._session, instance)
              lst_properties = ["config.files.vmPathName", "runtime.powerState",
                                "datastore"]
              props = self._session._call_method(vim_util,
                          "get_object_properties",
                          None, vm_ref, "VirtualMachine", lst_properties)
              query = vm_util.get_values_from_object_properties(
                      self._session, props)
              pwr_state = query['runtime.powerState']
  
              vm_config_pathname = query.get('config.files.vmPathName')
              vm_ds_path = None
              if vm_config_pathname is not None:
                  vm_ds_path = ds_obj.DatastorePath.parse(
                          vm_config_pathname)
  
              # Power off the VM if it is in PoweredOn state.
              if pwr_state == "poweredOn":
                  vm_util.power_off_instance(self._session, instance, vm_ref)
  
              # Un-register the VM
              try:
                  LOG.debug("Unregistering the VM", instance=instance)
                  self._session._call_method(self._session.vim,
                                             "UnregisterVM", vm_ref)
                  LOG.debug("Unregistered the VM", instance=instance)
              except Exception as excep:
                  LOG.warning(_LW("In vmwareapi:vmops:_destroy_instance, got "
                                  "this exception while un-registering the VM: "
                                  "%s"), excep)
              # Delete the folder holding the VM related content on
              # the datastore.
              if destroy_disks and vm_ds_path:
                  try:
                      dir_ds_compliant_path = vm_ds_path.parent
                      LOG.debug("Deleting contents of the VM from "
                                "datastore %(datastore_name)s",
                                {'datastore_name': vm_ds_path.datastore},
                                instance=instance)
                      ds_ref_ret = query['datastore']
                      ds_ref = ds_ref_ret.ManagedObjectReference[0]
                      dc_info = self.get_datacenter_ref_and_name(ds_ref)
                      ds_util.file_delete(self._session,
                                          dir_ds_compliant_path,
                                          dc_info.ref)
                      LOG.debug("Deleted contents of the VM from "
                                "datastore %(datastore_name)s",
                                {'datastore_name': vm_ds_path.datastore},
                                instance=instance)
                  except Exception:
                      LOG.warning(_LW("In vmwareapi:vmops:_destroy_instance, "
                                      "exception while deleting the VM contents "
                                      "from the disk"), exc_info=True)
          except exception.InstanceNotFound:
              LOG.warning(_LW('Instance does not exist on backend'),
                          instance=instance)
          except Exception:
              LOG.exception(_LE('Destroy instance failed'),
                            instance=instance)
          finally:
              vm_util.vm_ref_cache_delete(instance.uuid)
  
      def destroy(self, instance, destroy_disks=True):
          """Destroy a VM instance.
  
          Steps followed for each VM are:
          1. Power off, if it is in poweredOn state.
          2. Un-register.
          3. Delete the contents of the folder holding the VM related data.
          """
          if instance.task_state == task_states.RESIZE_REVERTING:
              return
  
          LOG.debug("Destroying instance", instance=instance)
          self._destroy_instance(instance, destroy_disks=destroy_disks)
          LOG.debug("Instance destroyed", instance=instance)
  
      def pause(self, instance):
          msg = _("pause not supported for vmwareapi")
          raise NotImplementedError(msg)
  
      def unpause(self, instance):
          msg = _("unpause not supported for vmwareapi")
          raise NotImplementedError(msg)
  
      def suspend(self, instance):
          """Suspend the specified instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          pwr_state = self._session._call_method(vim_util,
                      "get_dynamic_property", vm_ref,
                      "VirtualMachine", "runtime.powerState")
          # Only PoweredOn VMs can be suspended.
          if pwr_state == "poweredOn":
              LOG.debug("Suspending the VM", instance=instance)
              suspend_task = self._session._call_method(self._session.vim,
                      "SuspendVM_Task", vm_ref)
              self._session._wait_for_task(suspend_task)
              LOG.debug("Suspended the VM", instance=instance)
          # Raise Exception if VM is poweredOff
          elif pwr_state == "poweredOff":
              reason = _("instance is powered off and cannot be suspended.")
              raise exception.InstanceSuspendFailure(reason=reason)
          else:
              LOG.debug("VM was already in suspended state. So returning "
                        "without doing anything", instance=instance)
  
      def resume(self, instance):
          """Resume the specified instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          pwr_state = self._session._call_method(vim_util,
                                       "get_dynamic_property", vm_ref,
                                       "VirtualMachine", "runtime.powerState")
          if pwr_state.lower() == "suspended":
              LOG.debug("Resuming the VM", instance=instance)
              suspend_task = self._session._call_method(
                                          self._session.vim,
                                         "PowerOnVM_Task", vm_ref)
              self._session._wait_for_task(suspend_task)
              LOG.debug("Resumed the VM", instance=instance)
          else:
              reason = _("instance is not in a suspended state")
              raise exception.InstanceResumeFailure(reason=reason)
  
      def _get_rescue_device(self, instance, vm_ref):
          hardware_devices = self._session._call_method(vim_util,
                          "get_dynamic_property", vm_ref,
                          "VirtualMachine", "config.hardware.device")
          return vm_util.find_rescue_device(hardware_devices,
                                            instance)
  
      def rescue(self, context, instance, network_info, image_meta):
          """Rescue the specified instance.
  
          Attach the image that the instance was created from and boot from it.
          """
          vm_ref = vm_util.get_vm_ref(self._session, instance)
  
          # Get the root disk vmdk object
          vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                       uuid=instance.uuid)
          ds_ref = vmdk.device.backing.datastore
          datastore = ds_obj.get_datastore_by_ref(self._session, ds_ref)
          dc_info = self.get_datacenter_ref_and_name(datastore.ref)
  
          # Get the image details of the instance
          image_info = images.VMwareImage.from_image(instance.image_ref,
                                                     image_meta)
          vi = VirtualMachineInstanceConfigInfo(instance,
                                                image_info,
                                                datastore,
                                                dc_info,
                                                self._imagecache)
          vm_util.power_off_instance(self._session, instance, vm_ref)
  
          # Get the rescue disk path
          rescue_disk_path = datastore.build_path(instance.uuid,
                  "%s-rescue.%s" % (image_info.image_id, image_info.file_type))
  
          # Copy the cached image to the be the rescue disk. This will be used
          # as the rescue disk for the instance.
          ds_util.disk_copy(self._session, dc_info.ref,
                            vi.cache_image_path, rescue_disk_path)
          # Attach the rescue disk to the instance
          self._volumeops.attach_disk_to_vm(vm_ref, instance, vmdk.adapter_type,
                                            vmdk.disk_type, rescue_disk_path)
          # Get the rescue device and configure the boot order to
          # boot from this device
          rescue_device = self._get_rescue_device(instance, vm_ref)
          factory = self._session.vim.client.factory
          boot_spec = vm_util.get_vm_boot_spec(factory, rescue_device)
          # Update the VM with the new boot order and power on
          vm_util.reconfigure_vm(self._session, vm_ref, boot_spec)
          vm_util.power_on_instance(self._session, instance, vm_ref=vm_ref)
  
      def unrescue(self, instance, power_on=True):
          """Unrescue the specified instance."""
  
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          # Get the rescue device and detach it from the instance.
          try:
              rescue_device = self._get_rescue_device(instance, vm_ref)
          except exception.NotFound:
              with excutils.save_and_reraise_exception():
                  LOG.error(_LE('Unable to access the rescue disk'),
                            instance=instance)
          vm_util.power_off_instance(self._session, instance, vm_ref)
          self._volumeops.detach_disk_from_vm(vm_ref, instance, rescue_device,
                                              destroy_disk=True)
          if power_on:
              vm_util.power_on_instance(self._session, instance, vm_ref=vm_ref)
  
      def power_off(self, instance):
          """Power off the specified instance.
  
          :param instance: nova.objects.instance.Instance
          """
          vm_util.power_off_instance(self._session, instance)
  
      def power_on(self, instance):
          vm_util.power_on_instance(self._session, instance)
  
      def _update_instance_progress(self, context, instance, step, total_steps):
          """Update instance progress percent to reflect current step number
          """
          # Divide the action's workflow into discrete steps and "bump" the
          # instance's progress field as each step is completed.
          #
          # For a first cut this should be fine, however, for large VM images,
          # the clone disk step begins to dominate the equation. A
          # better approximation would use the percentage of the VM image that
          # has been streamed to the destination host.
          progress = round(float(step) / total_steps * 100)
          instance_uuid = instance.uuid
          LOG.debug("Updating instance '%(instance_uuid)s' progress to"
                    " %(progress)d",
                    {'instance_uuid': instance_uuid, 'progress': progress},
                    instance=instance)
          instance.progress = progress
          instance.save()
  
      def _resize_vm(self, context, instance, vm_ref, flavor):
          """Resizes the VM according to the flavor."""
          client_factory = self._session.vim.client.factory
          extra_specs = self._get_extra_specs(flavor)
          metadata = self._get_instance_metadata(context, instance)
          vm_resize_spec = vm_util.get_vm_resize_spec(client_factory,
                                                      int(flavor['vcpus']),
                                                      int(flavor['memory_mb']),
                                                      extra_specs,
                                                      metadata=metadata)
          vm_util.reconfigure_vm(self._session, vm_ref, vm_resize_spec)
  
      def _resize_disk(self, instance, vm_ref, vmdk, flavor):
          if (flavor['root_gb'] > instance.root_gb and
              flavor['root_gb'] > vmdk.capacity_in_bytes / units.Gi):
              root_disk_in_kb = flavor['root_gb'] * units.Mi
              ds_ref = vmdk.device.backing.datastore
              dc_info = self.get_datacenter_ref_and_name(ds_ref)
              folder = ds_obj.DatastorePath.parse(vmdk.path).dirname
              datastore = ds_obj.DatastorePath.parse(vmdk.path).datastore
              resized_disk = str(ds_obj.DatastorePath(datastore, folder,
                                 'resized.vmdk'))
              ds_util.disk_copy(self._session, dc_info.ref, vmdk.path,
                                str(resized_disk))
              self._extend_virtual_disk(instance, root_disk_in_kb, resized_disk,
                                        dc_info.ref)
              self._volumeops.detach_disk_from_vm(vm_ref, instance, vmdk.device)
              original_disk = str(ds_obj.DatastorePath(datastore, folder,
                                  'original.vmdk'))
              ds_util.disk_move(self._session, dc_info.ref, vmdk.path,
                                original_disk)
              ds_util.disk_move(self._session, dc_info.ref, resized_disk,
                                vmdk.path)
              self._volumeops.attach_disk_to_vm(vm_ref, instance,
                                                vmdk.adapter_type,
                                                vmdk.disk_type, vmdk.path)
  
      def _remove_ephemerals(self, vm_ref):
          devices = vm_util.get_ephemerals(self._session, vm_ref)
          if devices:
              vm_util.detach_devices_from_vm(self._session, vm_ref, devices)
  
      def _resize_create_ephemerals(self, vm_ref, instance, block_device_info):
          vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                       uuid=instance.uuid)
          ds_ref = vmdk.device.backing.datastore
          datastore = ds_obj.get_datastore_by_ref(self._session, ds_ref)
          dc_info = self.get_datacenter_ref_and_name(ds_ref)
          folder = ds_obj.DatastorePath.parse(vmdk.path).dirname
          self._create_ephemeral(block_device_info, instance, vm_ref,
                                 dc_info, datastore, folder, vmdk.adapter_type)
  
      def migrate_disk_and_power_off(self, context, instance, dest,
                                     flavor):
          """Transfers the disk of a running instance in multiple phases, turning
          off the instance before the end.
          """
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                       uuid=instance.uuid)
  
          # Checks if the migration needs a disk resize down.
          if (flavor['root_gb'] < instance.root_gb or
              (flavor['root_gb'] != 0 and
               flavor['root_gb'] < vmdk.capacity_in_bytes / units.Gi)):
              reason = _("Unable to shrink disk.")
              raise exception.InstanceFaultRollback(
                  exception.ResizeError(reason=reason))
  
          # TODO(garyk): treat dest parameter. Migration needs to be treated.
  
          # 0. Zero out the progress to begin
          self._update_instance_progress(context, instance,
                                         step=0,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
          # 1. Power off the instance
          vm_util.power_off_instance(self._session, instance, vm_ref)
          self._update_instance_progress(context, instance,
                                         step=1,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
          # 2. Reconfigure the VM properties
          self._resize_vm(context, instance, vm_ref, flavor)
  
          self._update_instance_progress(context, instance,
                                         step=2,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
          # 3.Reconfigure the disk properties
          self._resize_disk(instance, vm_ref, vmdk, flavor)
          self._update_instance_progress(context, instance,
                                         step=3,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
          # 4. Purge ephemeral disks
          self._remove_ephemerals(vm_ref)
          self._update_instance_progress(context, instance,
                                         step=4,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
      def confirm_migration(self, migration, instance, network_info):
          """Confirms a resize, destroying the source VM."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                       uuid=instance.uuid)
          ds_ref = vmdk.device.backing.datastore
          dc_info = self.get_datacenter_ref_and_name(ds_ref)
          folder = ds_obj.DatastorePath.parse(vmdk.path).dirname
          datastore = ds_obj.DatastorePath.parse(vmdk.path).datastore
          original_disk = ds_obj.DatastorePath(datastore, folder,
                                               'original.vmdk')
          ds_browser = self._get_ds_browser(ds_ref)
          if ds_util.file_exists(self._session, ds_browser,
                                 original_disk.parent,
                                 original_disk.basename):
              ds_util.disk_delete(self._session, dc_info.ref,
                                  str(original_disk))
  
      def finish_revert_migration(self, context, instance, network_info,
                                  block_device_info, power_on=True):
          """Finish reverting a resize."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          # Ensure that the VM is off
          vm_util.power_off_instance(self._session, instance, vm_ref)
          client_factory = self._session.vim.client.factory
          # Reconfigure the VM properties
          extra_specs = self._get_extra_specs(instance.flavor)
          metadata = self._get_instance_metadata(context, instance)
          vm_resize_spec = vm_util.get_vm_resize_spec(client_factory,
                                                      int(instance.vcpus),
                                                      int(instance.memory_mb),
                                                      extra_specs,
                                                      metadata=metadata)
          vm_util.reconfigure_vm(self._session, vm_ref, vm_resize_spec)
  
          # Reconfigure the disks if necessary
          vmdk = vm_util.get_vmdk_info(self._session, vm_ref,
                                       uuid=instance.uuid)
          ds_ref = vmdk.device.backing.datastore
          dc_info = self.get_datacenter_ref_and_name(ds_ref)
          folder = ds_obj.DatastorePath.parse(vmdk.path).dirname
          datastore = ds_obj.DatastorePath.parse(vmdk.path).datastore
          original_disk = ds_obj.DatastorePath(datastore, folder,
                                               'original.vmdk')
          ds_browser = self._get_ds_browser(ds_ref)
          if ds_util.file_exists(self._session, ds_browser,
                                 original_disk.parent,
                                 original_disk.basename):
              self._volumeops.detach_disk_from_vm(vm_ref, instance, vmdk.device)
              ds_util.disk_delete(self._session, dc_info.ref, vmdk.path)
              ds_util.disk_move(self._session, dc_info.ref,
                                str(original_disk), vmdk.path)
              self._volumeops.attach_disk_to_vm(vm_ref, instance,
                                                vmdk.adapter_type,
                                                vmdk.disk_type, vmdk.path)
          # Reconfigure ephemerals
          self._remove_ephemerals(vm_ref)
          self._resize_create_ephemerals(vm_ref, instance, block_device_info)
          if power_on:
              vm_util.power_on_instance(self._session, instance)
  
      def finish_migration(self, context, migration, instance, disk_info,
                           network_info, image_meta, resize_instance=False,
                           block_device_info=None, power_on=True):
          """Completes a resize, turning on the migrated instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
  
          # 5. Update ephemerals if necessary
          self._resize_create_ephemerals(vm_ref, instance, block_device_info)
  
          self._update_instance_progress(context, instance,
                                         step=5,
                                         total_steps=RESIZE_TOTAL_STEPS)
          # 6. Start VM
          if power_on:
              vm_util.power_on_instance(self._session, instance, vm_ref=vm_ref)
  
          self._update_instance_progress(context, instance,
                                         step=6,
                                         total_steps=RESIZE_TOTAL_STEPS)
  
      def live_migration(self, context, instance_ref, dest,
                         post_method, recover_method, block_migration=False):
          """Spawning live_migration operation for distributing high-load."""
          vm_ref = vm_util.get_vm_ref(self._session, instance_ref)
  
          host_ref = self._get_host_ref_from_name(dest)
          if host_ref is None:
              raise exception.HostNotFound(host=dest)
  
          LOG.debug("Migrating VM to host %s", dest, instance=instance_ref)
          try:
              vm_migrate_task = self._session._call_method(
                                      self._session.vim,
                                      "MigrateVM_Task", vm_ref,
                                      host=host_ref,
                                      priority="defaultPriority")
              self._session._wait_for_task(vm_migrate_task)
          except Exception:
              with excutils.save_and_reraise_exception():
                  recover_method(context, instance_ref, dest, block_migration)
          post_method(context, instance_ref, dest, block_migration)
          LOG.debug("Migrated VM to host %s", dest, instance=instance_ref)
  
      def poll_rebooting_instances(self, timeout, instances):
          """Poll for rebooting instances."""
          ctxt = nova_context.get_admin_context()
  
          instances_info = dict(instance_count=len(instances),
                  timeout=timeout)
  
          if instances_info["instance_count"] > 0:
              LOG.info(_LI("Found %(instance_count)d hung reboots "
                           "older than %(timeout)d seconds"), instances_info)
  
          for instance in instances:
              LOG.info(_LI("Automatically hard rebooting"), instance=instance)
              self.compute_api.reboot(ctxt, instance, "HARD")
  
      def get_info(self, instance):
          """Return data about the VM instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
  
          lst_properties = ["summary.config.numCpu",
                      "summary.config.memorySizeMB",
                      "runtime.powerState"]
          vm_props = self._session._call_method(vim_util,
                      "get_object_properties", None, vm_ref, "VirtualMachine",
                      lst_properties)
          query = vm_util.get_values_from_object_properties(
                  self._session, vm_props)
          max_mem = int(query.get('summary.config.memorySizeMB', 0)) * 1024
          num_cpu = int(query.get('summary.config.numCpu', 0))
          return hardware.InstanceInfo(
              state=VMWARE_POWER_STATES[query['runtime.powerState']],
              max_mem_kb=max_mem,
              mem_kb=max_mem,
              num_cpu=num_cpu)
  
      def _get_diagnostics(self, instance):
          """Return data about VM diagnostics."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          lst_properties = ["summary.config",
                            "summary.quickStats",
                            "summary.runtime"]
          vm_props = self._session._call_method(vim_util,
                      "get_object_properties", None, vm_ref, "VirtualMachine",
                      lst_properties)
          query = vm_util.get_values_from_object_properties(self._session,
                                                            vm_props)
          data = {}
          # All of values received are objects. Convert them to dictionaries
          for value in query.values():
              prop_dict = vim_util.object_to_dict(value, list_depth=1)
              data.update(prop_dict)
          return data
  
      def get_diagnostics(self, instance):
          """Return data about VM diagnostics."""
          data = self._get_diagnostics(instance)
          # Add a namespace to all of the diagnostsics
          return {'vmware:' + k: v for k, v in data.items()}
  
      def get_instance_diagnostics(self, instance):
          """Return data about VM diagnostics."""
          data = self._get_diagnostics(instance)
          state = data.get('powerState')
          if state:
              state = power_state.STATE_MAP[VMWARE_POWER_STATES[state]]
          uptime = data.get('uptimeSeconds', 0)
          config_drive = configdrive.required_by(instance)
          diags = diagnostics.Diagnostics(state=state,
                                          driver='vmwareapi',
                                          config_drive=config_drive,
                                          hypervisor_os='esxi',
                                          uptime=uptime)
          diags.memory_details.maximum = data.get('memorySizeMB', 0)
          diags.memory_details.used = data.get('guestMemoryUsage', 0)
          # TODO(garyk): add in cpu, nic and disk stats
          return diags
  
      def _get_vnc_console_connection(self, instance):
          """Return connection info for a vnc console."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          opt_value = self._session._call_method(vim_util,
                                 'get_dynamic_property',
                                 vm_ref, 'VirtualMachine',
                                 vm_util.VNC_CONFIG_KEY)
          if opt_value:
              port = int(opt_value.value)
          else:
              raise exception.ConsoleTypeUnavailable(console_type='vnc')
  
          return {'port': port,
                  'internal_access_path': None}
  
      @staticmethod
      def _get_machine_id_str(network_info):
          machine_id_str = ''
          for vif in network_info:
              # TODO(vish): add support for dns2
              # TODO(sateesh): add support for injection of ipv6 configuration
              network = vif['network']
              ip_v4 = netmask_v4 = gateway_v4 = broadcast_v4 = dns = None
              subnets_v4 = [s for s in network['subnets'] if s['version'] == 4]
              if len(subnets_v4) > 0:
                  if len(subnets_v4[0]['ips']) > 0:
                      ip_v4 = subnets_v4[0]['ips'][0]
                  if len(subnets_v4[0]['dns']) > 0:
                      dns = subnets_v4[0]['dns'][0]['address']
  
                  netmask_v4 = str(subnets_v4[0].as_netaddr().netmask)
                  gateway_v4 = subnets_v4[0]['gateway']['address']
                  broadcast_v4 = str(subnets_v4[0].as_netaddr().broadcast)
  
              interface_str = ";".join([vif['address'],
                                        ip_v4 and ip_v4['address'] or '',
                                        netmask_v4 or '',
                                        gateway_v4 or '',
                                        broadcast_v4 or '',
                                        dns or ''])
              machine_id_str = machine_id_str + interface_str + '#'
          return machine_id_str
  
      def _set_machine_id(self, client_factory, instance, network_info,
                          vm_ref=None):
          """Set the machine id of the VM for guest tools to pick up
          and reconfigure the network interfaces.
          """
          if vm_ref is None:
              vm_ref = vm_util.get_vm_ref(self._session, instance)
  
          machine_id_change_spec = vm_util.get_machine_id_change_spec(
                                   client_factory,
                                   self._get_machine_id_str(network_info))
  
          LOG.debug("Reconfiguring VM instance to set the machine id",
                    instance=instance)
          vm_util.reconfigure_vm(self._session, vm_ref, machine_id_change_spec)
          LOG.debug("Reconfigured VM instance to set the machine id",
                    instance=instance)
  
      @utils.synchronized('vmware.get_and_set_vnc_port')
      def _get_and_set_vnc_config(self, client_factory, instance, vm_ref):
          """Set the vnc configuration of the VM."""
          port = vm_util.get_vnc_port(self._session)
          vnc_config_spec = vm_util.get_vnc_config_spec(
                                        client_factory, port)
  
          LOG.debug("Reconfiguring VM instance to enable vnc on "
                    "port - %(port)s", {'port': port},
                    instance=instance)
          vm_util.reconfigure_vm(self._session, vm_ref, vnc_config_spec)
          LOG.debug("Reconfigured VM instance to enable vnc on "
                    "port - %(port)s", {'port': port},
                    instance=instance)
  
      def _get_ds_browser(self, ds_ref):
          ds_browser = self._datastore_browser_mapping.get(ds_ref.value)
          if not ds_browser:
              ds_browser = self._session._call_method(
                  vim_util, "get_dynamic_property", ds_ref, "Datastore",
                  "browser")
              self._datastore_browser_mapping[ds_ref.value] = ds_browser
          return ds_browser
  
      def _get_host_ref_from_name(self, host_name):
          """Get reference to the host with the name specified."""
          host_objs = self._session._call_method(vim_util, "get_objects",
                      "HostSystem", ["name"])
          vm_util._cancel_retrieve_if_necessary(self._session, host_objs)
          for host in host_objs:
              if hasattr(host, 'propSet'):
                  if host.propSet[0].val == host_name:
                      return host.obj
          return None
  
      def _create_folder_if_missing(self, ds_name, ds_ref, folder):
          """Create a folder if it does not exist.
  
          Currently there are two folder that are required on the datastore
           - base folder - the folder to store cached images
           - temp folder - the folder used for snapshot management and
                           image uploading
          This method is aimed to be used for the management of those
          folders to ensure that they are created if they are missing.
          The ds_util method mkdir will be used to check if the folder
          exists. If this throws and exception 'FileAlreadyExistsException'
          then the folder already exists on the datastore.
          """
          path = ds_obj.DatastorePath(ds_name, folder)
          dc_info = self.get_datacenter_ref_and_name(ds_ref)
          try:
              ds_util.mkdir(self._session, path, dc_info.ref)
              LOG.debug("Folder %s created.", path)
          except vexc.FileAlreadyExistsException:
              # NOTE(hartsocks): if the folder already exists, that
              # just means the folder was prepped by another process.
              pass
  
      def check_cache_folder(self, ds_name, ds_ref):
          """Check that the cache folder exists."""
          self._create_folder_if_missing(ds_name, ds_ref, self._base_folder)
  
      def check_temp_folder(self, ds_name, ds_ref):
          """Check that the temp folder exists."""
          self._create_folder_if_missing(ds_name, ds_ref, self._tmp_folder)
  
      def inject_network_info(self, instance, network_info):
          """inject network info for specified instance."""
          # Set the machine.id parameter of the instance to inject
          # the NIC configuration inside the VM
          client_factory = self._session.vim.client.factory
          self._set_machine_id(client_factory, instance, network_info)
  
      def manage_image_cache(self, context, instances):
          if not CONF.remove_unused_base_images:
              LOG.debug("Image aging disabled. Aging will not be done.")
              return
  
          datastores = ds_util.get_available_datastores(self._session,
                                                        self._cluster,
                                                        self._datastore_regex)
          datastores_info = []
          for ds in datastores:
              dc_info = self.get_datacenter_ref_and_name(ds.ref)
              datastores_info.append((ds, dc_info))
          self._imagecache.update(context, instances, datastores_info)
  
      def _get_valid_vms_from_retrieve_result(self, retrieve_result):
          """Returns list of valid vms from RetrieveResult object."""
          lst_vm_names = []
  
          while retrieve_result:
              for vm in retrieve_result.objects:
                  vm_name = None
                  conn_state = None
                  for prop in vm.propSet:
                      if prop.name == "name":
                          vm_name = prop.val
                      elif prop.name == "runtime.connectionState":
                          conn_state = prop.val
                  # Ignoring the orphaned or inaccessible VMs
                  if (conn_state not in ["orphaned", "inaccessible"] and
                      uuidutils.is_uuid_like(vm_name)):
                      lst_vm_names.append(vm_name)
              retrieve_result = self._session._call_method(vutil,
                                                           'continue_retrieval',
                                                           retrieve_result)
          return lst_vm_names
  
      def instance_exists(self, instance):
          try:
              vm_util.get_vm_ref(self._session, instance)
              return True
          except exception.InstanceNotFound:
              return False
  
      def attach_interface(self, instance, image_meta, vif):
          """Attach an interface to the instance."""
          vif_model = image_meta.get("hw_vif_model",
                                     constants.DEFAULT_VIF_MODEL)
          vif_model = vm_util.convert_vif_model(vif_model)
          vif_info = vmwarevif.get_vif_dict(self._session, self._cluster,
                                            vif_model, utils.is_neutron(), vif)
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          # Ensure that there is not a race with the port index management
          with lockutils.lock(instance.uuid,
                              lock_file_prefix='nova-vmware-hot-plug'):
              port_index = vm_util.get_attach_port_index(self._session, vm_ref)
              client_factory = self._session.vim.client.factory
              attach_config_spec = vm_util.get_network_attach_config_spec(
                                          client_factory, vif_info, port_index)
              LOG.debug("Reconfiguring VM to attach interface",
                        instance=instance)
              try:
                  vm_util.reconfigure_vm(self._session, vm_ref,
                                         attach_config_spec)
              except Exception as e:
                  LOG.error(_LE('Attaching network adapter failed. Exception: '
                                ' %s'),
                            e, instance=instance)
                  raise exception.InterfaceAttachFailed(
                          instance_uuid=instance.uuid)
          LOG.debug("Reconfigured VM to attach interface", instance=instance)
  
      def detach_interface(self, instance, vif):
          """Detach an interface from the instance."""
          vm_ref = vm_util.get_vm_ref(self._session, instance)
          # Ensure that there is not a race with the port index management
          with lockutils.lock(instance.uuid,
                              lock_file_prefix='nova-vmware-hot-plug'):
              port_index = vm_util.get_vm_detach_port_index(self._session,
                                                            vm_ref,
                                                            vif['id'])
              if port_index is None:
                  msg = _("No device with interface-id %s exists on "
                          "VM") % vif['id']
                  raise exception.NotFound(msg)
  
              hardware_devices = self._session._call_method(vim_util,
                              "get_dynamic_property", vm_ref,
                              "VirtualMachine", "config.hardware.device")
              device = vmwarevif.get_network_device(hardware_devices,
                                                    vif['address'])
              if device is None:
                  msg = _("No device with MAC address %s exists on the "
                          "VM") % vif['address']
                  raise exception.NotFound(msg)
  
              client_factory = self._session.vim.client.factory
              detach_config_spec = vm_util.get_network_detach_config_spec(
                                          client_factory, device, port_index)
              LOG.debug("Reconfiguring VM to detach interface",
                        instance=instance)
              try:
                  vm_util.reconfigure_vm(self._session, vm_ref,
                                         detach_config_spec)
              except Exception as e:
                  LOG.error(_LE('Detaching network adapter failed. Exception: '
                                '%s'),
                            e, instance=instance)
                  raise exception.InterfaceDetachFailed(
                          instance_uuid=instance.uuid)
          LOG.debug("Reconfigured VM to detach interface", instance=instance)
  
      def _use_disk_image_as_full_clone(self, vm_ref, vi):
          """Uses cached image disk by copying it into the VM directory."""
  
          instance_folder = vi.instance.uuid
          root_disk_name = "%s.vmdk" % vi.instance.uuid
          root_disk_ds_loc = vi.datastore.build_path(instance_folder,
                                                     root_disk_name)
  
          vm_util.copy_virtual_disk(
                  self._session,
                  vi.dc_info.ref,
                  str(vi.cache_image_path),
                  str(root_disk_ds_loc))
  
          self._extend_if_required(
                  vi.dc_info, vi.ii, vi.instance, str(root_disk_ds_loc))
  
          self._volumeops.attach_disk_to_vm(
                  vm_ref, vi.instance,
                  vi.ii.adapter_type, vi.ii.disk_type,
                  str(root_disk_ds_loc),
                  vi.root_gb * units.Mi, False)
  
      def _sized_image_exists(self, sized_disk_ds_loc, ds_ref):
          ds_browser = self._get_ds_browser(ds_ref)
          return ds_util.file_exists(
                  self._session, ds_browser, sized_disk_ds_loc.parent,
                  sized_disk_ds_loc.basename)
  
      def _use_disk_image_as_linked_clone(self, vm_ref, vi):
          """Uses cached image as parent of a COW child in the VM directory."""
  
          sized_image_disk_name = "%s.vmdk" % vi.ii.image_id
          if vi.root_gb > 0:
              sized_image_disk_name = "%s.%s.vmdk" % (vi.ii.image_id, vi.root_gb)
          sized_disk_ds_loc = vi.cache_image_folder.join(sized_image_disk_name)
  
          # Ensure only a single thread extends the image at once.
          # We do this by taking a lock on the name of the extended
          # image. This allows multiple threads to create resized
          # copies simultaneously, as long as they are different
          # sizes. Threads attempting to create the same resized copy
          # will be serialized, with only the first actually creating
          # the copy.
          #
          # Note that the object is in a per-nova cache directory,
          # so inter-nova locking is not a concern. Consequently we
          # can safely use simple thread locks.
  
          with lockutils.lock(str(sized_disk_ds_loc),
                              lock_file_prefix='nova-vmware-image'):
  
              if not self._sized_image_exists(sized_disk_ds_loc,
                                              vi.datastore.ref):
                  LOG.debug("Copying root disk of size %sGb", vi.root_gb,
                            instance=vi.instance)
                  try:
                      vm_util.copy_virtual_disk(
                              self._session,
                              vi.dc_info.ref,
                              str(vi.cache_image_path),
                              str(sized_disk_ds_loc))
                  except Exception as e:
                      LOG.warning(_LW("Root disk file creation "
                                      "failed - %s"), e)
                      with excutils.save_and_reraise_exception():
                          LOG.error(_LE('Failed to copy cached '
                                        'image %(source)s to '
                                        '%(dest)s for resize: '
                                        '%(error)s'),
                                    {'source': vi.cache_image_path,
                                     'dest': sized_disk_ds_loc,
                                     'error': e})
                          try:
                              ds_util.file_delete(self._session,
                                                  sized_disk_ds_loc,
                                                  vi.dc_info.ref)
                          except vexc.FileNotFoundException:
                              # File was never created: cleanup not
                              # required
                              pass
  
                  # Resize the copy to the appropriate size. No need
                  # for cleanup up here, as _extend_virtual_disk
                  # already does it
                  self._extend_if_required(
                          vi.dc_info, vi.ii, vi.instance, str(sized_disk_ds_loc))
  
          # Associate the sized image disk to the VM by attaching to the VM a
          # COW child of said disk.
          self._volumeops.attach_disk_to_vm(
                  vm_ref, vi.instance,
                  vi.ii.adapter_type, vi.ii.disk_type,
                  str(sized_disk_ds_loc),
                  vi.root_gb * units.Mi, vi.ii.linked_clone)
  
      def _use_iso_image(self, vm_ref, vi):
          """Uses cached image as a bootable virtual cdrom."""
  
          self._attach_cdrom_to_vm(
                  vm_ref, vi.instance, vi.datastore.ref,
                  str(vi.cache_image_path))
  
          # Optionally create and attach blank disk
          if vi.root_gb > 0:
              instance_folder = vi.instance.uuid
              root_disk_name = "%s.vmdk" % vi.instance.uuid
              root_disk_ds_loc = vi.datastore.build_path(instance_folder,
                                                         root_disk_name)
  
              # It is pointless to COW a blank disk
              linked_clone = False
  
              vm_util.create_virtual_disk(
                      self._session, vi.dc_info.ref,
                      vi.ii.adapter_type,
                      vi.ii.disk_type,
                      str(root_disk_ds_loc),
                      vi.root_gb * units.Mi)
  
              self._volumeops.attach_disk_to_vm(
                      vm_ref, vi.instance,
                      vi.ii.adapter_type, vi.ii.disk_type,
                      str(root_disk_ds_loc),
                      vi.root_gb * units.Mi, linked_clone)
  
      def _update_datacenter_cache_from_objects(self, dcs):
          """Updates the datastore/datacenter cache."""
  
          while dcs:
              for dco in dcs.objects:
                  dc_ref = dco.obj
                  ds_refs = []
                  prop_dict = vm_util.propset_dict(dco.propSet)
                  name = prop_dict.get('name')
                  vmFolder = prop_dict.get('vmFolder')
                  datastore_refs = prop_dict.get('datastore')
                  if datastore_refs:
                      datastore_refs = datastore_refs.ManagedObjectReference
                      for ds in datastore_refs:
                          ds_refs.append(ds.value)
                  else:
                      LOG.debug("Datacenter %s doesn't have any datastore "
                                "associated with it, ignoring it", name)
                  for ds_ref in ds_refs:
                      self._datastore_dc_mapping[ds_ref] = DcInfo(ref=dc_ref,
                              name=name, vmFolder=vmFolder)
              dcs = self._session._call_method(vutil, 'continue_retrieval',
                                               dcs)
  
      def get_datacenter_ref_and_name(self, ds_ref):
          """Get the datacenter name and the reference."""
          dc_info = self._datastore_dc_mapping.get(ds_ref.value)
          if not dc_info:
              dcs = self._session._call_method(vim_util, "get_objects",
                      "Datacenter", ["name", "datastore", "vmFolder"])
              self._update_datacenter_cache_from_objects(dcs)
              dc_info = self._datastore_dc_mapping.get(ds_ref.value)
          return dc_info
  
      def list_instances(self):
          """Lists the VM instances that are registered with vCenter cluster."""
          properties = ['name', 'runtime.connectionState']
          LOG.debug("Getting list of instances from cluster %s",
                    self._cluster)
          vms = []
          if self._root_resource_pool:
              vms = self._session._call_method(
                  vim_util, 'get_inner_objects', self._root_resource_pool, 'vm',
                  'VirtualMachine', properties)
          lst_vm_names = self._get_valid_vms_from_retrieve_result(vms)
  
          LOG.debug("Got total of %s instances", str(len(lst_vm_names)))
          return lst_vm_names
  
      def get_vnc_console(self, instance):
          """Return connection info for a vnc console using vCenter logic."""
  
          # vCenter does not run virtual machines and does not run
          # a VNC proxy. Instead, you need to tell OpenStack to talk
          # directly to the ESX host running the VM you are attempting
          # to connect to via VNC.
  
          vnc_console = self._get_vnc_console_connection(instance)
          host_name = vm_util.get_host_name_for_vm(
                          self._session,
                          instance)
          vnc_console['host'] = host_name
  
          # NOTE: VM can move hosts in some situations. Debug for admins.
          LOG.debug("VM %(uuid)s is currently on host %(host_name)s",
                    {'uuid': instance.name, 'host_name': host_name},
                    instance=instance)
          return ctype.ConsoleVNC(**vnc_console)
  