def _detach_volume_iscsi(self, connection_info, instance, mountpoint): """Detach volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("Detach_volume: %(instance_name)s, %(mountpoint)s", {'mountpoint': mountpoint, 'instance_name': instance_name}, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name, uuid = self._iscsi_get_target(data) if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") device = vm_util.get_rdm_disk(hardware_devices, uuid) if device is None: raise exception.StorageError(reason=_("Unable to find volume")) self.detach_disk_from_vm(vm_ref, instance, device, destroy_disk=True) LOG.info(_("Mountpoint %(mountpoint)s detached from " "instance %(instance_name)s"), {'mountpoint': mountpoint, 'instance_name': instance_name}, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance, adapter_type=None): """Attach iscsi volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug("_attach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name = self._iscsi_discover_target(data)[0] if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) vmdk = vm_util.get_vmdk_info(self._session, vm_ref) adapter_type = adapter_type or vmdk.adapter_type self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', device_name=device_name) LOG.debug("Attached ISCSI: %s", connection_info, instance=instance)
def _attach_volume_vmdk(self, connection_info, instance, adapter_type=None): """Attach vmdk volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) LOG.debug("_attach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) # Get details required for adding disk device such as # adapter_type, disk_type vmdk = vm_util.get_vmdk_info(self._session, volume_ref) adapter_type = adapter_type or vmdk.adapter_type # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % adapter_type raise exception.Invalid(msg) # Attach the disk to virtual machine instance self.attach_disk_to_vm(vm_ref, instance, adapter_type, vmdk.disk_type, vmdk_path=vmdk.path) # Store the uuid of the volume_device self._update_volume_details(vm_ref, data['volume_id'], vmdk.device.backing.uuid) LOG.debug("Attached VMDK: %s", connection_info, instance=instance)
def _attach_volume_vmdk(self, connection_info, instance): """Attach vmdk volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) LOG.debug("_attach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) # Get details required for adding disk device such as # adapter_type, disk_type hw_devices = self._session._call_method(vim_util, 'get_dynamic_property', volume_ref, 'VirtualMachine', 'config.hardware.device') (volume_vmdk_path, adapter_type, disk_type) = vm_util.get_vmdk_path_and_adapter_type(hw_devices) # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % adapter_type raise exception.Invalid(msg) # Attach the disk to virtual machine instance self.attach_disk_to_vm(vm_ref, instance, adapter_type, disk_type, vmdk_path=volume_vmdk_path) # Store the uuid of the volume_device self._update_volume_details(vm_ref, instance, data['volume_id']) LOG.debug("Attached VMDK: %s", connection_info, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance, adapter_type=None): """Attach iscsi volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug("_attach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name = self._iscsi_discover_target(data)[0] if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) if adapter_type is None: # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method( vutil, "get_object_property", vm_ref, "config.hardware.device") adapter_type = vm_util.get_scsi_adapter_type(hardware_devices) self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', device_name=device_name) LOG.debug("Attached ISCSI: %s", connection_info, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get details required for adding disk device such as # adapter_type, disk_type hw_devices = self._session._call_method(vim_util, 'get_dynamic_property', volume_ref, 'VirtualMachine', 'config.hardware.device') (vmdk_file_path, adapter_type, disk_type) = vm_util.get_vmdk_path_and_adapter_type(hw_devices) # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % adapter_type raise exception.Invalid(msg) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=adapter_type, disk_type=disk_type) self.detach_disk_from_vm(vm_ref, instance, device) LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get details required for adding disk device such as # adapter_type, disk_type vmdk = vm_util.get_vmdk_info(self._session, volume_ref) # IDE does not support disk hotplug if vmdk.adapter_type == constants.ADAPTER_TYPE_IDE: state = vm_util.get_vm_state(self._session, instance) if state.lower() != 'poweredoff': raise exception.Invalid(_('%s does not support disk ' 'hotplug.') % vmdk.adapter_type) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=vmdk.adapter_type, disk_type=vmdk.disk_type) self.detach_disk_from_vm(vm_ref, instance, device) # Remove key-value pair <volume_id, vmdk_uuid> from instance's # extra config. Setting value to empty string will remove the key. self._update_volume_details(vm_ref, data['volume_id'], "") LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def _attach_volume_vmdk(self, connection_info, instance, mountpoint): """Attach vmdk volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] # Get volume details from volume ref volume_ref = self._get_volume_ref(data['volume']) volume_device = self._get_vmdk_base_volume_device(volume_ref) volume_vmdk_path = volume_device.backing.fileName # Get details required for adding disk device such as # adapter_type, disk_type hw_devices = self._session._call_method(vim_util, 'get_dynamic_property', vm_ref, 'VirtualMachine', 'config.hardware.device') (vmdk_file_path, adapter_type, disk_type) = vm_util.get_vmdk_path_and_adapter_type(hw_devices) # Attach the disk to virtual machine instance self.attach_disk_to_vm(vm_ref, instance, adapter_type, disk_type, vmdk_path=volume_vmdk_path) # Store the uuid of the volume_device self._update_volume_details(vm_ref, instance, data['volume_id']) LOG.info(_("Mountpoint %(mountpoint)s attached to " "instance %(instance_name)s"), {'mountpoint': mountpoint, 'instance_name': instance_name}, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get details required for adding disk device such as # adapter_type, disk_type vmdk = vm_util.get_vmdk_info(self._session, volume_ref) # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and vmdk.adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % vmdk.adapter_type raise exception.Invalid(msg) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=vmdk.adapter_type, disk_type=vmdk.disk_type) self.detach_disk_from_vm(vm_ref, instance, device) # Remove key-value pair <volume_id, vmdk_uuid> from instance's # extra config. Setting value to empty string will remove the key. self._update_volume_details(vm_ref, data['volume_id'], "") LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance, mountpoint): """Detach volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("Detach_volume: %(instance_name)s, %(mountpoint)s", { 'mountpoint': mountpoint, 'instance_name': instance_name }, instance=instance) data = connection_info['data'] device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get the volume ref volume_ref = self._get_volume_ref(data['volume']) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref) self.detach_disk_from_vm(vm_ref, instance, device) LOG.info(_LI("Mountpoint %(mountpoint)s detached from " "vmdk instance %(instance_name)s"), { 'mountpoint': mountpoint, 'instance_name': instance_name }, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance, adapter_type=None): """Attach iscsi volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug("_attach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name = self._iscsi_discover_target(data)[0] if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) if adapter_type is None: # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method( vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") adapter_type = vm_util.get_scsi_adapter_type(hardware_devices) self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', device_name=device_name) LOG.debug("Attached ISCSI: %s", connection_info, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance, mountpoint): """Attach iscsi volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug("Attach_volume: %(connection_info)s, %(instance_name)s, " "%(mountpoint)s", {'connection_info': connection_info, 'instance_name': instance_name, 'mountpoint': mountpoint}, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name = self._iscsi_discover_target(data)[0] if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") (vmdk_file_path, adapter_type, disk_type) = vm_util.get_vmdk_path_and_adapter_type(hardware_devices) self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', device_name=device_name) LOG.info(_("Mountpoint %(mountpoint)s attached to " "instance %(instance_name)s"), {'mountpoint': mountpoint, 'instance_name': instance_name}, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get details required for adding disk device such as # adapter_type, disk_type vmdk = vm_util.get_vmdk_info(self._session, volume_ref) # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and vmdk.adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % vmdk.adapter_type raise exception.Invalid(msg) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=vmdk.adapter_type, disk_type=vmdk.disk_type) self.detach_disk_from_vm(vm_ref, instance, device) LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def get_volume_connector(self, instance): """Return volume connector information.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) iqn = volume_util.get_host_iqn(self._session, self._cluster) return {'ip': CONF.vmware.host_ip, 'initiator': iqn, 'host': CONF.vmware.host_ip, 'instance': vm_ref.value}
def get_volume_connector(self, instance): """Return volume connector information.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) iqn = volume_util.get_host_iqn(self._session, self._cluster) return { 'ip': CONF.vmware.host_ip, 'initiator': iqn, 'host': CONF.vmware.host_ip, 'instance': vm_ref.value }
def get_volume_connector(self, instance): """Return volume connector information.""" try: vm_ref = vm_util.get_vm_ref(self._session, instance) except exception.InstanceNotFound: vm_ref = None iqn = self._iscsi_get_host_iqn() connector = {"ip": CONF.vmware.host_ip, "initiator": iqn, "host": CONF.vmware.host_ip} if vm_ref: connector["instance"] = vm_ref.value return connector
def get_volume_connector(self, instance): """Return volume connector information.""" try: vm_ref = vm_util.get_vm_ref(self._session, instance) except exception.InstanceNotFound: vm_ref = None iqn = volume_util.get_host_iqn(self._session, self._cluster) connector = {'ip': CONF.vmware.host_ip, 'initiator': iqn, 'host': CONF.vmware.host_ip} if vm_ref: connector['instance'] = vm_ref.value return connector
def get_volume_connector(self, instance): """Return volume connector information.""" try: vm_ref = vm_util.get_vm_ref(self._session, instance) except exception.InstanceNotFound: vm_ref = None iqn = self._iscsi_get_host_iqn() connector = {'ip': CONF.vmware.host_ip, 'initiator': iqn, 'host': CONF.vmware.host_ip} if vm_ref: connector['instance'] = vm_ref.value return connector
def _detach_volume_fcd(self, connection_info, instance): """Detach fcd volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] adapter_type = data['adapter_type'] if adapter_type == constants.ADAPTER_TYPE_IDE: state = vm_util.get_vm_state(self._session, instance) if state != power_state.SHUTDOWN: raise exception.Invalid(_('%s does not support disk ' 'hotplug.') % adapter_type) vm_util.detach_fcd(self._session, vm_ref, data['id'])
def attach_root_volume(self, connection_info, instance, mountpoint): """Attach a root volume to the VM instance.""" driver_type = connection_info['driver_volume_type'] LOG.debug(_("Root volume attach. Driver type: %s"), driver_type, instance=instance) if driver_type == 'vmdk': vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get the volume ref volume_ref = self._get_volume_ref(data['volume']) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref) self.attach_volume(connection_info, instance, mountpoint)
def attach_root_volume(self, connection_info, instance, datastore, adapter_type=None): """Attach a root volume to the VM instance.""" driver_type = connection_info["driver_volume_type"] LOG.debug("Root volume attach. Driver type: %s", driver_type, instance=instance) if driver_type == constants.DISK_FORMAT_VMDK: vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info["data"] # Get the volume ref volume_ref = self._get_volume_ref(data["volume"]) # Pick the resource pool on which the instance resides. Move the # volume to the datastore of the instance. res_pool = self._get_res_pool_of_vm(vm_ref) self._relocate_vmdk_volume(volume_ref, res_pool, datastore) self.attach_volume(connection_info, instance, adapter_type)
def _attach_volume_fcd(self, connection_info, instance): """Attach fcd volume storage to VM instance.""" LOG.debug("_attach_volume_fcd: %s", connection_info, instance=instance) vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] adapter_type = data['adapter_type'] if adapter_type == constants.ADAPTER_TYPE_IDE: state = vm_util.get_vm_state(self._session, instance) if state != power_state.SHUTDOWN: raise exception.Invalid(_('%s does not support disk ' 'hotplug.') % adapter_type) self._attach_fcd(vm_ref, adapter_type, data['id'], data['ds_ref_val']) LOG.debug("Attached fcd: %s", connection_info, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get the volume ref volume_ref = self._get_volume_ref(data['volume']) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref) self.detach_disk_from_vm(vm_ref, instance, device) LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def attach_root_volume(self, connection_info, instance, mountpoint, datastore): """Attach a root volume to the VM instance.""" driver_type = connection_info['driver_volume_type'] LOG.debug("Root volume attach. Driver type: %s", driver_type, instance=instance) if driver_type == 'vmdk': vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] # Get the volume ref volume_ref = self._get_volume_ref(data['volume']) # Pick the resource pool on which the instance resides. Move the # volume to the datastore of the instance. res_pool = self._get_res_pool_of_vm(vm_ref) self._relocate_vmdk_volume(volume_ref, res_pool, datastore) self.attach_volume(connection_info, instance, mountpoint)
def attach_root_volume(self, connection_info, instance, datastore, adapter_type=None): """Attach a root volume to the VM instance.""" driver_type = connection_info['driver_volume_type'] LOG.debug("Root volume attach. Driver type: %s", driver_type, instance=instance) if driver_type == constants.DISK_FORMAT_VMDK: vm_ref = vm_util.get_vm_ref(self._session, instance) data = connection_info['data'] # Get the volume ref volume_ref = self._get_volume_ref(data) # Pick the resource pool on which the instance resides. Move the # volume to the datastore of the instance. res_pool = self._get_res_pool_of_vm(vm_ref) vm_util.relocate_vm(self._session, volume_ref, res_pool, datastore) self.attach_volume(connection_info, instance, adapter_type)
def test_get_vm_ref(self): """Check retrieval of vm reference using uuid or name""" respool = fake.ResourcePool() fake._create_object('ResourcePool', respool) cluster = fake.ClusterComputeResource() cluster._add_root_resource_pool(respool.obj) fake._create_object('ClusterComputeResource', cluster) vm_folder = fake.Folder(name='fake-folder') fake_folders = fake.FakeRetrieveResult() fake_folders.add_object(vm_folder) fake_pools = fake.FakeRetrieveResult() fake_pools.add_object(respool) fake_clusters = fake.FakeRetrieveResult() fake_clusters.add_object(cluster) optionVal = fake.OptionValue(key="nvp.vm-uuid", value="test-uuid-1") virtualMachine1 = fake.VirtualMachine(name="VM-1", instanceUuid="test-uuid-1", resourcePool=respool.obj, extra_config=[optionVal]) fake_vms = fake.FakeRetrieveResult() fake_vms.add_object(virtualMachine1) session = fake_session(fake_virtual_machines=fake_vms, fake_resource_pools=fake_pools, fake_cluster=fake_clusters, fake_vm_folder=fake_folders) driver = fake_driver(session, cluster_ref=cluster.obj) instance = {} vm_util.add_vm_to_cache(driver, 'test-uuid-1', { 'vmref': virtualMachine1.obj, "template": "false" }) # Verify retrieval based on uuid instance['uuid'] = 'test-uuid-1' returned_vm_ref = vm_util.get_vm_ref(driver._session, instance) returned_vm_name = driver._session._call_method( None, "get_dynamic_property", returned_vm_ref, "VirtualMachine", "name") self.assertEquals(virtualMachine1.obj, returned_vm_ref) self.assertEquals("VM-1", returned_vm_name) # Verify exception for wrong uuid instance['uuid'] = 'non-existent-uuid' self.assertRaises(exception.InstanceNotFound, vm_util.get_vm_ref, driver._session, instance)
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None): _vmops = self._get_vmops_for_compute_node(instance['node']) _vmops.spawn(context=context, instance=instance, image_meta=image_meta, injected_files=injected_files, admin_password=admin_password, network_info=None, block_device_info=block_device_info, power_on=False) vm_ref = vm_util.get_vm_ref(self._session, instance) if vm_ref is None: raise exception.InstanceNotFound(instance_id=instance['uuid']) image_info = images.VMwareImage.from_image(instance.image_ref, image_meta) self._create_virtual_nic(instance, image_info, network_info, vm_ref) self._power_on_vm(instance, vm_ref)
def spawn(self, context, instance, image_meta, injected_files, admin_password, allocations, network_info=None, block_device_info=None): self.ovsvapp_vmops.spawn(context=context, instance=instance, image_meta=image_meta, injected_files=injected_files, admin_password=admin_password, network_info=None, block_device_info=block_device_info) vm_ref = vm_util.get_vm_ref(self._session, instance) if vm_ref is None: raise exception.InstanceNotFound(instance_id=instance['uuid']) image_info = images.VMwareImage.from_image(context, instance.image_ref, image_meta) self._create_virtual_nic(instance, image_info, network_info, vm_ref)
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None): image_meta = objects.ImageMeta.from_dict(image_meta) self.ovsvapp_vmops.spawn(context=context, instance=instance, image_meta=image_meta, injected_files=injected_files, admin_password=admin_password, network_info=None, block_device_info=block_device_info) vm_ref = vm_util.get_vm_ref(self._session, instance) if vm_ref is None: raise exception.InstanceNotFound(instance_id=instance['uuid']) image_info = images.VMwareImage.from_image(instance.image_ref, image_meta) self._create_virtual_nic(instance, image_info, network_info, vm_ref) self._power_on_vm(instance, vm_ref)
def _attach_volume_iscsi(self, connection_info, instance, mountpoint): """Attach iscsi volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug( _("Attach_volume: %(connection_info)s, %(instance_name)s, " "%(mountpoint)s"), { 'connection_info': connection_info, 'instance_name': instance_name, 'mountpoint': mountpoint }) data = connection_info['data'] mount_unit = volume_util.mountpoint_to_number(mountpoint) # Discover iSCSI Target device_name, uuid = self.discover_st(data) if device_name is None: raise volume_util.StorageError(_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method( vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") vmdk_file_path, controller_key, adapter_type, disk_type, unit_number \ = vm_util.get_vmdk_path_and_adapter_type(hardware_devices) # Figure out the correct unit number if unit_number < mount_unit: unit_number = mount_unit else: unit_number = unit_number + 1 self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', controller_key=controller_key, unit_number=unit_number, device_name=device_name) LOG.info( _("Mountpoint %(mountpoint)s attached to " "instance %(instance_name)s"), { 'mountpoint': mountpoint, 'instance_name': instance_name })
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) hardware_devices = vm_util.get_hardware_devices(self._session, vm_ref) adapter_type = None for hw_device in hardware_devices: if hw_device.key == device.controllerKey: adapter_type = vm_util.CONTROLLER_TO_ADAPTER_TYPE.get( hw_device.__class__.__name__) break # IDE does not support disk hotplug if adapter_type == constants.ADAPTER_TYPE_IDE: state = vm_util.get_vm_state(self._session, instance) if state != power_state.SHUTDOWN: raise exception.Invalid( _('%s does not support disk ' 'hotplug.') % adapter_type) disk_type = vm_util._get_device_disk_type(device) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=adapter_type, disk_type=disk_type) self.detach_disk_from_vm(vm_ref, instance, device) # Remove key-value pair <volume_id, vmdk_uuid> from instance's # extra config. Setting value to empty string will remove the key. self._update_volume_details(vm_ref, data['volume_id'], "") LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def _detach_volume_iscsi(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info["data"] # Discover iSCSI Target device_name, uuid = self._iscsi_get_target(data) if device_name is None: raise exception.StorageError(reason=_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vutil, "get_object_property", vm_ref, "config.hardware.device") device = vm_util.get_rdm_disk(hardware_devices, uuid) if device is None: raise exception.DiskNotFound(message=_("Unable to find volume")) self.detach_disk_from_vm(vm_ref, instance, device, destroy_disk=True) LOG.debug("Detached ISCSI: %s", connection_info, instance=instance)
def _detach_volume_vmdk(self, connection_info, instance, mountpoint): """Detach volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug(_("Detach_volume: %(instance_name)s, %(mountpoint)s"), {'mountpoint': mountpoint, 'instance_name': instance_name}) data = connection_info['data'] device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get the volume ref volume_ref = self._get_volume_ref(data['volume']) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref) self.detach_disk_from_vm(vm_ref, instance, device) LOG.info(_("Mountpoint %(mountpoint)s detached from " "instance %(instance_name)s"), {'mountpoint': mountpoint, 'instance_name': instance_name})
def _detach_volume_vmdk(self, connection_info, instance): """Detach volume storage to VM instance.""" # this code is for sync openstack db, If volume is detached by vmware, # don't take the "detach_disk" action meta_key = "sync_vmware_os-volume_attachments" if meta_key in instance.metadata: LOG.debug("Detached VMDK: sync_vmware_os-volume_attachments") return vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_vmdk: %s", connection_info, instance=instance) data = connection_info['data'] volume_ref = self._get_volume_ref(data['volume']) device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get details required for adding disk device such as # adapter_type, disk_type vmdk = vm_util.get_vmdk_info(self._session, volume_ref) # IDE does not support disk hotplug if (instance.vm_state == vm_states.ACTIVE and vmdk.adapter_type == constants.ADAPTER_TYPE_IDE): msg = _('%s does not support disk hotplug.') % vmdk.adapter_type raise exception.Invalid(msg) # If the instance is synced from vmware, # don't take the "attach_disk" action meta_key = "sync_vmware_" + str(instance.uuid) if meta_key not in instance.metadata: self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref, adapter_type=vmdk.adapter_type, disk_type=vmdk.disk_type) self.detach_disk_from_vm(vm_ref, instance, device) # Remove key-value pair <volume_id, vmdk_uuid> from instance's # extra config. Setting value to empty string will remove the key. self._update_volume_details(vm_ref, data['volume_id'], "") LOG.debug("Detached VMDK: %s", connection_info, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance): """Attach iscsi volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug("_attach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name = self._iscsi_discover_target(data)[0] if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) vmdk = vm_util.get_vmdk_info(self._session, vm_ref) self.attach_disk_to_vm(vm_ref, instance, vmdk.adapter_type, 'rdmp', device_name=device_name) LOG.debug("Attached ISCSI: %s", connection_info, instance=instance)
def _detach_volume_iscsi(self, connection_info, instance): """Detach volume storage to VM instance.""" vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug("_detach_volume_iscsi: %s", connection_info, instance=instance) data = connection_info['data'] # Discover iSCSI Target device_name, uuid = self._iscsi_get_target(data) if device_name is None: raise exception.StorageError( reason=_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = vm_util.get_hardware_devices(self._session, vm_ref) device = vm_util.get_rdm_disk(hardware_devices, uuid) if device is None: raise exception.DiskNotFound(message=_("Unable to find volume")) self.detach_disk_from_vm(vm_ref, instance, device, destroy_disk=True) LOG.debug("Detached ISCSI: %s", connection_info, instance=instance)
def _attach_volume_iscsi(self, connection_info, instance, mountpoint): """Attach iscsi volume storage to VM instance.""" instance_name = instance['name'] vm_ref = vm_util.get_vm_ref(self._session, instance) # Attach Volume to VM LOG.debug(_("Attach_volume: %(connection_info)s, %(instance_name)s, " "%(mountpoint)s"), {'connection_info': connection_info, 'instance_name': instance_name, 'mountpoint': mountpoint}) data = connection_info['data'] mount_unit = volume_util.mountpoint_to_number(mountpoint) # Discover iSCSI Target device_name, uuid = self.discover_st(data) if device_name is None: raise volume_util.StorageError(_("Unable to find iSCSI Target")) # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") vmdk_file_path, controller_key, adapter_type, disk_type, unit_number \ = vm_util.get_vmdk_path_and_adapter_type(hardware_devices) # Figure out the correct unit number if unit_number < mount_unit: unit_number = mount_unit else: unit_number = unit_number + 1 self.attach_disk_to_vm(vm_ref, instance, adapter_type, 'rdmp', controller_key=controller_key, unit_number=unit_number, device_name=device_name) LOG.info(_("Mountpoint %(mountpoint)s attached to " "instance %(instance_name)s"), {'mountpoint': mountpoint, 'instance_name': instance_name})
def _detach_volume_vmdk(self, connection_info, instance, mountpoint): """Detach volume storage to VM instance.""" instance_name = instance["name"] vm_ref = vm_util.get_vm_ref(self._session, instance) # Detach Volume from VM LOG.debug( "Detach_volume: %(instance_name)s, %(mountpoint)s", {"mountpoint": mountpoint, "instance_name": instance_name}, instance=instance, ) data = connection_info["data"] device = self._get_vmdk_backed_disk_device(vm_ref, data) # Get the volume ref volume_ref = self._get_volume_ref(data["volume"]) self._consolidate_vmdk_volume(instance, vm_ref, device, volume_ref) self.detach_disk_from_vm(vm_ref, instance, device) LOG.info( _LI("Mountpoint %(mountpoint)s detached from " "vmdk instance %(instance_name)s"), {"mountpoint": mountpoint, "instance_name": instance_name}, instance=instance, )