def host_maintenance_mode(self, host, mode): """Starts/Stops host maintenance. On start, it triggers guest VMs evacuation. """ ctxt = context.get_admin_context() if not mode: self._set_service_state(host=host, binary='nova-compute', is_disabled=False) LOG.info(_LI('Host is no longer under maintenance.')) return 'off_maintenance' self._set_service_state(host=host, binary='nova-compute', is_disabled=True) vms_uuids = self._vmops.list_instance_uuids() for vm_uuid in vms_uuids: self._wait_for_instance_pending_task(ctxt, vm_uuid) vm_names = self._vmutils.list_instances() for vm_name in vm_names: self._migrate_vm(ctxt, vm_name, host) vms_uuid_after_migration = self._vmops.list_instance_uuids() remaining_vms = len(vms_uuid_after_migration) if remaining_vms == 0: LOG.info( _LI('All vms have been migrated successfully.' 'Host is down for maintenance')) return 'on_maintenance' raise exception.MigrationError(reason=_( 'Not all vms have been migrated: %s remaining instances.') % remaining_vms)
def host_maintenance_mode(self, host, mode): """Starts/Stops host maintenance. On start, it triggers guest VMs evacuation. """ ctxt = context.get_admin_context() if not mode: self._set_service_state(host=host, binary='nova-compute', is_disabled=False) LOG.info(_LI('Host is no longer under maintenance.')) return 'off_maintenance' self._set_service_state(host=host, binary='nova-compute', is_disabled=True) vms_uuids = self._vmops.list_instance_uuids() for vm_uuid in vms_uuids: self._wait_for_instance_pending_task(ctxt, vm_uuid) vm_names = self._vmutils.list_instances() for vm_name in vm_names: self._migrate_vm(ctxt, vm_name, host) vms_uuid_after_migration = self._vmops.list_instance_uuids() remaining_vms = len(vms_uuid_after_migration) if remaining_vms == 0: LOG.info(_LI('All vms have been migrated successfully.' 'Host is down for maintenance')) return 'on_maintenance' raise exception.MigrationError( reason=_('Not all vms have been migrated: %s remaining instances.') % remaining_vms)
def _create_config_drive(self, instance, injected_files, admin_password, network_info, rescue=False): if CONF.config_drive_format != 'iso9660': raise vmutils.UnsupportedConfigDriveFormatException( _('Invalid config_drive_format "%s"') % CONF.config_drive_format) LOG.info(_LI('Using config drive for instance'), instance=instance) extra_md = {} if admin_password and CONF.hyperv.config_drive_inject_password: extra_md['admin_pass'] = admin_password inst_md = instance_metadata.InstanceMetadata(instance, content=injected_files, extra_md=extra_md, network_info=network_info) configdrive_path_iso = self._pathutils.get_configdrive_path( instance.name, constants.DVD_FORMAT, rescue=rescue) LOG.info(_LI('Creating config drive at %(path)s'), {'path': configdrive_path_iso}, instance=instance) with configdrive.ConfigDriveBuilder(instance_md=inst_md) as cdb: try: cdb.make_drive(configdrive_path_iso) except processutils.ProcessExecutionError as e: with excutils.save_and_reraise_exception(): LOG.error(_LE('Creating config drive failed with ' 'error: %s'), e, instance=instance) if not CONF.hyperv.config_drive_cdrom: configdrive_path = self._pathutils.get_configdrive_path( instance.name, constants.DISK_FORMAT_VHD, rescue=rescue) utils.execute(CONF.hyperv.qemu_img_cmd, 'convert', '-f', 'raw', '-O', 'vpc', configdrive_path_iso, configdrive_path, attempts=1) self._pathutils.remove(configdrive_path_iso) else: configdrive_path = configdrive_path_iso return configdrive_path
def _failover_migrate(self, instance_name, old_host, new_host): """This method will check if the generated event is a legitimate failover to this node. If it is, it will proceed to prepare the failovered VM if necessary and update the owner of the compute vm in nova and ports in neutron. """ LOG.info( _LI('Checking instance failover %(instance)s to %(new_host)s ' 'from host %(old_host)s.'), { 'instance': instance_name, 'new_host': new_host, 'old_host': old_host }) instance = self._get_instance_by_name(instance_name) nw_info = self._network_api.get_instance_nw_info( self._context, instance) if not instance: # Some instances on the hypervisor may not be tracked by nova LOG.debug('Instance %s does not exist in nova. Skipping.', instance_name) return if instance.task_state == task_states.MIGRATING: # In case of live migration triggered by the user, we get the # event that the instance changed host but we do not want # to treat it as a failover. LOG.debug('Instance %s is live migrating.', instance_name) return if instance.host.upper() == self._this_node.upper(): return if old_host and old_host.upper() == self._this_node.upper(): LOG.debug('Actions at source node.') self._vmops.unplug_vifs(instance, nw_info) return elif new_host.upper() != self._this_node.upper(): LOG.debug('Instance %s did not failover to this node.', instance_name) return LOG.info(_LI('Instance %(instance)s failover to %(host)s.'), { 'instance': instance_name, 'host': new_host }) self._nova_failover_server(instance, new_host) self._failover_migrate_networks(instance, old_host) self._vmops.post_start_vifs(instance, nw_info) self._serial_console_ops.start_console_handler(instance_name)
def _failover_migrate(self, instance_name, old_host, new_host): """This method will check if the generated event is a legitimate failover to this node. If it is, it will proceed to prepare the failovered VM if necessary and update the owner of the compute vm in nova and ports in neutron. """ LOG.info(_LI('Checking instance failover %(instance)s to %(new_host)s ' 'from host %(old_host)s.'), {'instance': instance_name, 'new_host': new_host, 'old_host': old_host}) instance = self._get_instance_by_name(instance_name) nw_info = self._network_api.get_instance_nw_info(self._context, instance) if not instance: # Some instances on the hypervisor may not be tracked by nova LOG.debug('Instance %s does not exist in nova. Skipping.', instance_name) return if instance.task_state == task_states.MIGRATING: # In case of live migration triggered by the user, we get the # event that the instance changed host but we do not want # to treat it as a failover. LOG.debug('Instance %s is live migrating.', instance_name) return if instance.host.upper() == self._this_node.upper(): return if old_host and old_host.upper() == self._this_node.upper(): LOG.debug('Actions at source node.') self._vmops.unplug_vifs(instance, nw_info) return elif new_host.upper() != self._this_node.upper(): LOG.debug('Instance %s did not failover to this node.', instance_name) return LOG.info(_LI('Instance %(instance)s failover to %(host)s.'), {'instance': instance_name, 'host': new_host}) self._nova_failover_server(instance, new_host) self._failover_migrate_networks(instance, old_host) self._vmops.post_start_vifs(instance, nw_info) self._serial_console_ops.start_console_handler(instance_name)
def destroy(self, instance, network_info=None, block_device_info=None, destroy_disks=True): instance_name = instance.name LOG.info(_LI("Got request to destroy instance"), instance=instance) try: if self._vmutils.vm_exists(instance_name): self.power_off(instance) self._vmutils.destroy_vm(instance_name) self._volumeops.disconnect_volumes(block_device_info) else: LOG.debug("Instance not found", instance=instance) if destroy_disks: self._delete_disk_files(instance_name) if network_info: for vif in network_info: vif_driver = self._get_vif_driver(vif.get('type')) vif_driver.unplug(instance, vif) except Exception: with excutils.save_and_reraise_exception(): LOG.exception(_LE('Failed to destroy instance: %s'), instance_name)
def get_instance_dir(self, instance_name, remote_server=None, create_dir=True, remove_dir=False): instance_dir = self._get_instances_sub_dir( instance_name, remote_server, create_dir=False, remove_dir=False) # In some situations, the instance files may reside at a different # location than the configured one. if not os.path.exists(instance_dir): vmutils = (self._vmutils if not remote_server else utilsfactory.get_vmutils(remote_server)) try: instance_dir = vmutils.get_vm_config_root_dir( instance_name) if remote_server: instance_dir = self._get_remote_unc_path(remote_server, instance_dir) LOG.info(_LI("Found instance dir at non-default location: %s"), instance_dir) except os_win_exc.HyperVVMNotFoundException: pass self._check_dir(instance_dir, create_dir=create_dir, remove_dir=remove_dir) return instance_dir
def destroy(self, instance, network_info=None, block_device_info=None, destroy_disks=True): instance_name = instance.name LOG.info(_LI("Got request to destroy instance"), instance=instance) try: if self._vmutils.vm_exists(instance_name): # Stop the VM first. self._vmutils.stop_vm_jobs(instance_name) self.power_off(instance) self._vmutils.destroy_vm(instance_name) self._volumeops.disconnect_volumes(block_device_info) else: LOG.debug("Instance not found", instance=instance) if destroy_disks: self._delete_disk_files(instance_name) if network_info: for vif in network_info: vif_driver = self._get_vif_driver(vif.get('type')) vif_driver.unplug(instance, vif) except Exception: with excutils.save_and_reraise_exception(): LOG.exception(_LE('Failed to destroy instance: %s'), instance_name)
def validate_initiators(self): # The MS iSCSI initiator service can manage the software iSCSI # initiator as well as hardware initiators. initiator_list = CONF.hyperv.iscsi_initiator_list valid_initiators = True if not initiator_list: LOG.info( _LI("No iSCSI initiator was explicitly requested. " "The Microsoft iSCSI initiator will choose the " "initiator when estabilishing sessions.")) else: available_initiators = self._iscsi_utils.get_iscsi_initiators() for initiator in initiator_list: if initiator not in available_initiators: valid_initiators = False msg = _LW("The requested initiator %(req_initiator)s " "is not in the list of available initiators: " "%(avail_initiators)s.") LOG.warning( msg, dict(req_initiator=initiator, avail_initiators=available_initiators)) return valid_initiators
def _migrate_vm(self, ctxt, vm_name, host): try: instance_uuid = self._vmutils.get_instance_uuid(vm_name) if not instance_uuid: LOG.info( _LI('VM "%s" running on this host was not created by ' 'nova. Skip migrating this vm to a new host.'), vm_name) return instance = objects.Instance.get_by_uuid(ctxt, instance_uuid) if instance.vm_state == vm_states.ACTIVE: self._api.live_migrate(ctxt, instance, block_migration=False, disk_over_commit=False, host_name=None) else: self._api.resize(ctxt, instance, flavor_id=None, clean_shutdown=True) self._wait_for_instance_pending_task(ctxt, instance_uuid) except Exception as e: LOG.error(_LE('Migrating vm failed with error: %s '), e) raise exception.MigrationError(reason='Unable to migrate %s.' % vm_name)
def destroy(self, instance, network_info=None, block_device_info=None, destroy_disks=True): instance_name = instance.name LOG.info(_LI("Got request to destroy instance"), instance=instance) try: if self._vmutils.vm_exists(instance_name): # Stop the VM first. self._vmutils.stop_vm_jobs(instance_name) self.power_off(instance) self._vmutils.destroy_vm(instance_name) self._volumeops.disconnect_volumes(block_device_info) else: LOG.debug("Instance not found", instance=instance) if destroy_disks: self._delete_disk_files(instance_name) self.unplug_vifs(instance, network_info) except Exception: with excutils.save_and_reraise_exception(): LOG.exception(_LE('Failed to destroy instance: %s'), instance_name)
def get_instance_dir(self, instance_name, remote_server=None, create_dir=True, remove_dir=False): instance_dir = self._get_instances_sub_dir(instance_name, remote_server, create_dir=False, remove_dir=False) # In some situations, the instance files may reside at a different # location than the configured one. if not os.path.exists(instance_dir): vmutils = (self._vmutils if not remote_server else utilsfactory.get_vmutils(remote_server)) try: instance_dir = vmutils.get_vm_config_root_dir(instance_name) if remote_server: instance_dir = self._get_remote_unc_path( remote_server, instance_dir) LOG.info(_LI("Found instance dir at non-default location: %s"), instance_dir) except os_win_exc.HyperVVMNotFoundException: pass self._check_dir(instance_dir, create_dir=create_dir, remove_dir=remove_dir) return instance_dir
def _soft_shutdown(self, instance, timeout=CONF.hyperv.wait_soft_reboot_seconds, retry_interval=SHUTDOWN_TIME_INCREMENT): """Perform a soft shutdown on the VM. :return: True if the instance was shutdown within time limit, False otherwise. """ LOG.debug("Performing Soft shutdown on instance", instance=instance) while timeout > 0: # Perform a soft shutdown on the instance. # Wait maximum timeout for the instance to be shutdown. # If it was not shutdown, retry until it succeeds or a maximum of # time waited is equal to timeout. wait_time = min(retry_interval, timeout) try: LOG.debug("Soft shutdown instance, timeout remaining: %d", timeout, instance=instance) self._vmutils.soft_shutdown_vm(instance.name) if self._wait_for_power_off(instance.name, wait_time): LOG.info(_LI("Soft shutdown succeeded."), instance=instance) return True except os_win_exc.HyperVException as e: # Exception is raised when trying to shutdown the instance # while it is still booting. LOG.debug("Soft shutdown failed: %s", e, instance=instance) time.sleep(wait_time) timeout -= retry_interval LOG.warning(_LW("Timed out while waiting for soft shutdown."), instance=instance) return False
def _soft_shutdown(self, instance, timeout=CONF.hyperv.wait_soft_reboot_seconds, retry_interval=SHUTDOWN_TIME_INCREMENT): """Perform a soft shutdown on the VM. :return: True if the instance was shutdown within time limit, False otherwise. """ LOG.debug("Performing Soft shutdown on instance", instance=instance) while timeout > 0: # Perform a soft shutdown on the instance. # Wait maximum timeout for the instance to be shutdown. # If it was not shutdown, retry until it succeeds or a maximum of # time waited is equal to timeout. wait_time = min(retry_interval, timeout) try: LOG.debug("Soft shutdown instance, timeout remaining: %d", timeout, instance=instance) self._vmutils.soft_shutdown_vm(instance.name) if self._wait_for_power_off(instance.name, wait_time): LOG.info(_LI("Soft shutdown succeeded."), instance=instance) return True except vmutils.HyperVException as e: # Exception is raised when trying to shutdown the instance # while it is still booting. LOG.debug("Soft shutdown failed: %s", e, instance=instance) time.sleep(wait_time) timeout -= retry_interval LOG.warning(_LW("Timed out while waiting for soft shutdown."), instance=instance) return False
def _remove_if_old_image(self, image): backing_files = self._get_image_backing_files(image) max_age_seconds = CONF.remove_unused_original_minimum_age_seconds for img in backing_files: age_seconds = self._pathutils.get_age_of_file(img) if age_seconds > max_age_seconds: LOG.info(_LI("Removing old, unused image: %s"), img) self._remove_old_image(img)
def ensure_share_mounted(self, connection_info): export_path = self._get_export_path(connection_info) if self._smbutils.is_local_share(export_path): LOG.info( _LI("Skipping mounting share %s, " "using local path instead."), export_path) elif not self._smbutils.check_smb_mapping(export_path): opts_str = connection_info['data'].get('options') or '' username, password = self._parse_credentials(opts_str) self._smbutils.mount_smb_share(export_path, username=username, password=password)
def ensure_share_mounted(self, connection_info): export_path = self._get_export_path(connection_info) if self._smbutils.is_local_share(export_path): LOG.info(_LI("Skipping mounting share %s, " "using local path instead."), export_path) elif not self._smbutils.check_smb_mapping(export_path): opts_str = connection_info['data'].get('options') or '' username, password = self._parse_credentials(opts_str) self._smbutils.mount_smb_share(export_path, username=username, password=password)
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None): """Create a new VM and start it.""" LOG.info(_LI("Spawning new instance"), instance=instance) instance_name = instance.name if self._vmutils.vm_exists(instance_name): raise exception.InstanceExists(name=instance_name) # Make sure we're starting with a clean slate. self._delete_disk_files(instance_name) if 'properties' in image_meta and 'mtwilson_trustpolicy_location' in image_meta[ 'properties']: instance['metadata']['mtwilson_trustpolicy_location'] = image_meta[ 'properties']['mtwilson_trustpolicy_location'] instance.save() if self._volumeops.ebs_root_in_block_devices(block_device_info): root_vhd_path = None else: root_vhd_path = self._create_root_vhd(context, instance) eph_vhd_path = self.create_ephemeral_vhd(instance) # TODO(lpetrut): move this to the create_instance method. vm_gen = self.get_image_vm_generation(root_vhd_path, image_meta) try: self.create_instance(instance, network_info, block_device_info, root_vhd_path, eph_vhd_path, vm_gen, image_meta) LOG.info(instance) if configdrive.required_by(instance): configdrive_path = self._create_config_drive( instance, injected_files, admin_password, network_info) self.attach_config_drive(instance, configdrive_path, vm_gen) self.power_on(instance, network_info=network_info) except Exception: with excutils.save_and_reraise_exception(): self.destroy(instance)
def connect_volume(self, connection_info): connection_properties = connection_info['data'] auth_method = connection_properties.get('auth_method') if auth_method and auth_method.upper() != 'CHAP': LOG.error( _LE("Unsupported iSCSI authentication " "method: %(auth_method)s."), dict(auth_method=auth_method)) raise exception.UnsupportedBDMVolumeAuthMethod( auth_method=auth_method) volume_connected = False for (initiator_name, target_portal, target_iqn, target_lun) in self._get_all_paths(connection_properties): try: msg = _LI("Attempting to estabilish an iSCSI session to " "target %(target_iqn)s on portal %(target_portal)s " "acessing LUN %(target_lun)s using initiator " "%(initiator_name)s.") LOG.info( msg, dict(target_portal=target_portal, target_iqn=target_iqn, target_lun=target_lun, initiator_name=initiator_name)) self._iscsi_utils.login_storage_target( target_lun=target_lun, target_iqn=target_iqn, target_portal=target_portal, auth_username=connection_properties.get('auth_username'), auth_password=connection_properties.get('auth_password'), mpio_enabled=CONF.hyperv.use_multipath_io, initiator_name=initiator_name) volume_connected = True if not CONF.hyperv.use_multipath_io: break except os_win_exc.OSWinException: LOG.exception(_LE("Could not connect iSCSI target %s."), target_iqn) if not volume_connected: raise exception.VolumeAttachFailed( _("Could not connect volume %s.") % connection_properties['volume_id'])
def connect_volume(self, connection_info): connection_properties = connection_info['data'] auth_method = connection_properties.get('auth_method') if auth_method and auth_method.upper() != 'CHAP': LOG.error(_LE("Unsupported iSCSI authentication " "method: %(auth_method)s."), dict(auth_method=auth_method)) raise exception.UnsupportedBDMVolumeAuthMethod( auth_method=auth_method) volume_connected = False for (initiator_name, target_portal, target_iqn, target_lun) in self._get_all_paths(connection_properties): try: msg = _LI("Attempting to estabilish an iSCSI session to " "target %(target_iqn)s on portal %(target_portal)s " "acessing LUN %(target_lun)s using initiator " "%(initiator_name)s.") LOG.info(msg, dict(target_portal=target_portal, target_iqn=target_iqn, target_lun=target_lun, initiator_name=initiator_name)) self._iscsi_utils.login_storage_target( target_lun=target_lun, target_iqn=target_iqn, target_portal=target_portal, auth_username=connection_properties.get('auth_username'), auth_password=connection_properties.get('auth_password'), mpio_enabled=CONF.hyperv.use_multipath_io, initiator_name=initiator_name) volume_connected = True if not CONF.hyperv.use_multipath_io: break except os_win_exc.OSWinException: LOG.exception(_LE("Could not connect iSCSI target %s."), target_iqn) if not volume_connected: raise exception.VolumeAttachFailed( _("Could not connect volume %s.") % connection_properties['volume_id'])
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None): """Create a new VM and start it.""" LOG.info(_LI("Spawning new instance"), instance=instance) instance_name = instance.name if self._vmutils.vm_exists(instance_name): raise exception.InstanceExists(name=instance_name) # Make sure we're starting with a clean slate. self._delete_disk_files(instance_name) if 'properties' in image_meta and 'mtwilson_trustpolicy_location' in image_meta['properties']: instance['metadata']['mtwilson_trustpolicy_location'] = image_meta['properties']['mtwilson_trustpolicy_location'] instance.save() if self._volumeops.ebs_root_in_block_devices(block_device_info): root_vhd_path = None else: root_vhd_path = self._create_root_vhd(context, instance) eph_vhd_path = self.create_ephemeral_vhd(instance) # TODO(lpetrut): move this to the create_instance method. vm_gen = self.get_image_vm_generation(root_vhd_path, image_meta) try: self.create_instance(instance, network_info, block_device_info, root_vhd_path, eph_vhd_path, vm_gen, image_meta) LOG.info(instance) if configdrive.required_by(instance): configdrive_path = self._create_config_drive(instance, injected_files, admin_password, network_info) self.attach_config_drive(instance, configdrive_path, vm_gen) self.power_on(instance, network_info=network_info) except Exception: with excutils.save_and_reraise_exception(): self.destroy(instance)
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None): """Create a new VM and start it.""" LOG.debug(_LI("Spawning new instance"), instance=instance) instance_name = instance.name if self._vmutils.vm_exists(instance_name): raise exception.InstanceExists(name=instance_name) # Make sure we're starting with a clean slate. self._delete_disk_files(instance_name) if 'properties' in image_meta and 'mtwilson_trustpolicy_location' in image_meta['properties']: instance['metadata']['mtwilson_trustpolicy_location'] = image_meta['properties']['mtwilson_trustpolicy_location'] instance.save() LOG.debug("Inside spawn ") vm_gen = self.get_image_vm_generation(instance.uuid, image_meta) self._block_device_manager.validate_and_update_bdi( instance, image_meta, vm_gen, block_device_info) root_device = block_device_info['root_disk'] self._create_root_device(context, instance, root_device, vm_gen) self._create_ephemerals(instance, block_device_info['ephemerals']) try: with self.wait_vif_plug_events(instance, network_info): self.create_instance(instance, network_info, root_device, block_device_info, vm_gen, image_meta) LOG.info(instance) if configdrive.required_by(instance): configdrive_path = self._create_config_drive(instance, injected_files, admin_password, network_info) self.attach_config_drive(instance, configdrive_path, vm_gen) self.set_boot_order(vm_gen, block_device_info, instance.name) self.power_on(instance, network_info=network_info) except Exception: with excutils.save_and_reraise_exception(): self.destroy(instance)
def _migrate_vm(self, ctxt, vm_name, host): try: instance_uuid = self._vmutils.get_instance_uuid(vm_name) if not instance_uuid: LOG.info(_LI('VM "%s" running on this host was not created by ' 'nova. Skip migrating this vm to a new host.'), vm_name) return instance = objects.Instance.get_by_uuid(ctxt, instance_uuid) if instance.vm_state == vm_states.ACTIVE: self._api.live_migrate(ctxt, instance, block_migration=False, disk_over_commit=False, host_name=None) else: self._api.resize(ctxt, instance, flavor_id=None, clean_shutdown=True) self._wait_for_instance_pending_task(ctxt, instance_uuid) except Exception as e: LOG.error(_LE('Migrating vm failed with error: %s '), e) raise exception.MigrationError(reason='Unable to migrate %s.' % vm_name)
def get_iscsi_initiator(self): """Get iscsi initiator name for this machine.""" computer_system = self._conn_cimv2.Win32_ComputerSystem()[0] hostname = computer_system.name keypath = ("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\" "iSCSI\\Discovery") try: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keypath, 0, _winreg.KEY_ALL_ACCESS) temp = _winreg.QueryValueEx(key, 'DefaultInitiatorName') initiator_name = str(temp[0]) _winreg.CloseKey(key) except Exception: LOG.info(_LI("The ISCSI initiator name can't be found. " "Choosing the default one")) initiator_name = "iqn.1991-05.com.microsoft:" + hostname.lower() if computer_system.PartofDomain: initiator_name += '.' + computer_system.Domain.lower() return initiator_name
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None): """Create a new VM and start it.""" LOG.info(_LI("Spawning new instance"), instance=instance) instance_name = instance.name if self._vmutils.vm_exists(instance_name): raise exception.InstanceExists(name=instance_name) # Make sure we're starting with a clean slate. self._delete_disk_files(instance_name) vm_gen = self.get_image_vm_generation(instance.uuid, image_meta) self._block_device_manager.validate_and_update_bdi( instance, image_meta, vm_gen, block_device_info) root_device = block_device_info['root_disk'] self._create_root_device(context, instance, root_device, vm_gen) self._create_ephemerals(instance, block_device_info['ephemerals']) try: with self.wait_vif_plug_events(instance, network_info): self.create_instance(instance, network_info, root_device, block_device_info, vm_gen, image_meta) if configdrive.required_by(instance): configdrive_path = self._create_config_drive( instance, injected_files, admin_password, network_info) self.attach_config_drive(instance, configdrive_path, vm_gen) self.set_boot_order(vm_gen, block_device_info, instance.name) self.power_on(instance, network_info=network_info) except Exception: with excutils.save_and_reraise_exception(): self.destroy(instance)
def get_iscsi_initiator(self): """Get iscsi initiator name for this machine.""" computer_system = self._conn_cimv2.Win32_ComputerSystem()[0] hostname = computer_system.name keypath = ("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\" "iSCSI\\Discovery") try: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keypath, 0, _winreg.KEY_ALL_ACCESS) temp = _winreg.QueryValueEx(key, 'DefaultInitiatorName') initiator_name = str(temp[0]) _winreg.CloseKey(key) except Exception: LOG.info( _LI("The ISCSI initiator name can't be found. " "Choosing the default one")) initiator_name = "iqn.1991-05.com.microsoft:" + hostname.lower() if computer_system.PartofDomain: initiator_name += '.' + computer_system.Domain.lower() return initiator_name
def validate_initiators(self): # The MS iSCSI initiator service can manage the software iSCSI # initiator as well as hardware initiators. initiator_list = CONF.hyperv.iscsi_initiator_list valid_initiators = True if not initiator_list: LOG.info(_LI("No iSCSI initiator was explicitly requested. " "The Microsoft iSCSI initiator will choose the " "initiator when estabilishing sessions.")) else: available_initiators = self._iscsi_utils.get_iscsi_initiators() for initiator in initiator_list: if initiator not in available_initiators: valid_initiators = False msg = _LW("The requested initiator %(req_initiator)s " "is not in the list of available initiators: " "%(avail_initiators)s.") LOG.warning(msg, dict(req_initiator=initiator, avail_initiators=available_initiators)) return valid_initiators