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_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 _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_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(
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 _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 _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 _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 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, 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 _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 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,
)
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 _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)
