570 lines
24 KiB
Python
570 lines
24 KiB
Python
# Copyright 2015 IBM Corp.
|
|
#
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from pypowervm.tasks import scsi_mapper as pvm_smap
|
|
|
|
from oslo_log import log as logging
|
|
from taskflow import task
|
|
from taskflow.types import failure as task_fail
|
|
|
|
from nova_powervm.virt.powervm.disk import driver as disk_driver
|
|
from nova_powervm.virt.powervm import exception as npvmex
|
|
from nova_powervm.virt.powervm.i18n import _LI
|
|
from nova_powervm.virt.powervm.i18n import _LW
|
|
from nova_powervm.virt.powervm import media
|
|
from nova_powervm.virt.powervm import mgmt
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class ConnectVolume(task.Task):
|
|
"""The task to connect a volume to an instance."""
|
|
|
|
def __init__(self, vol_drv):
|
|
"""Create the task.
|
|
|
|
:param vol_drv: The volume driver (see volume folder). Ties the
|
|
storage to a connection type (ex. vSCSI or NPIV).
|
|
"""
|
|
self.vol_drv = vol_drv
|
|
self.vol_id = self.vol_drv.connection_info['data']['volume_id']
|
|
|
|
super(ConnectVolume, self).__init__(name='connect_vol_%s' %
|
|
self.vol_id)
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Connecting volume %(vol)s to instance %(inst)s'),
|
|
{'vol': self.vol_id, 'inst': self.vol_drv.instance.name})
|
|
self.vol_drv.connect_volume()
|
|
|
|
def revert(self, result, flow_failures):
|
|
# The parameters have to match the execute method, plus the response +
|
|
# failures even if only a subset are used.
|
|
LOG.warning(_LW('Volume %(vol)s for instance %(inst)s to be '
|
|
'disconnected'),
|
|
{'vol': self.vol_id, 'inst': self.vol_drv.instance.name})
|
|
|
|
# Note that the rollback is *instant*. Resetting the FeedTask ensures
|
|
# immediate rollback.
|
|
self.vol_drv.reset_stg_ftsk()
|
|
try:
|
|
# We attempt to disconnect in case we 'partially connected'. In
|
|
# the connect scenario, perhaps one of the Virtual I/O Servers
|
|
# was connected. This attempts to clear anything out to make sure
|
|
# the terminate connection runs smoothly.
|
|
self.vol_drv.disconnect_volume()
|
|
except npvmex.VolumeDetachFailed as e:
|
|
# Only log that the volume detach failed. Should not be blocking
|
|
# due to being in the revert flow.
|
|
LOG.warning(_LW("Unable to disconnect volume for %(inst)s during "
|
|
"rollback. Error was: %(error)s"),
|
|
{'inst': self.vol_drv.instance.name,
|
|
'error': e.message})
|
|
|
|
|
|
class DisconnectVolume(task.Task):
|
|
"""The task to disconnect a volume from an instance."""
|
|
|
|
def __init__(self, vol_drv):
|
|
"""Create the task.
|
|
|
|
:param vol_drv: The volume driver (see volume folder). Ties the
|
|
storage to a connection type (ex. vSCSI or NPIV).
|
|
"""
|
|
self.vol_drv = vol_drv
|
|
self.vol_id = self.vol_drv.connection_info['data']['volume_id']
|
|
super(DisconnectVolume, self).__init__(name='disconnect_vol_%s' %
|
|
self.vol_id)
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Disconnecting volume %(vol)s from instance %(inst)s'),
|
|
{'vol': self.vol_id, 'inst': self.vol_drv.instance.name})
|
|
self.vol_drv.disconnect_volume()
|
|
|
|
def revert(self, result, flow_failures):
|
|
# The parameters have to match the execute method, plus the response +
|
|
# failures even if only a subset are used.
|
|
LOG.warning(_LW('Volume %(vol)s for instance %(inst)s to be '
|
|
're-connected'),
|
|
{'vol': self.vol_id, 'inst': self.vol_drv.instance.name})
|
|
|
|
# Note that the rollback is *instant*. Resetting the FeedTask ensures
|
|
# immediate rollback.
|
|
self.vol_drv.reset_stg_ftsk()
|
|
try:
|
|
# We try to reconnect the volume here so that it maintains its
|
|
# linkage (in the hypervisor) to the VM. This makes it easier for
|
|
# operators to understand the linkage between the VMs and volumes
|
|
# in error scenarios. This is simply useful for debug purposes
|
|
# if there is an operational error.
|
|
self.vol_drv.connect_volume()
|
|
except npvmex.VolumeAttachFailed as e:
|
|
# Only log that the volume attach failed. Should not be blocking
|
|
# due to being in the revert flow. See comment above.
|
|
LOG.warning(_LW("Unable to re-connect volume for %(inst)s during "
|
|
"rollback. Error was: %(error)s"),
|
|
{'inst': self.vol_drv.instance.name,
|
|
'error': e.message})
|
|
|
|
|
|
class CreateDiskForImg(task.Task):
|
|
"""The Task to create the disk from an image in the storage."""
|
|
|
|
def __init__(self, disk_dvr, context, instance, image_meta, disk_size=0,
|
|
image_type=disk_driver.DiskType.BOOT):
|
|
"""Create the Task.
|
|
|
|
Provides the 'disk_dev_info' for other tasks. Comes from the disk_dvr
|
|
create_disk_from_image method.
|
|
|
|
:param disk_dvr: The storage driver.
|
|
:param context: The context passed into the driver method.
|
|
:param instance: The nova instance.
|
|
:param nova.objects.ImageMeta image_meta:
|
|
The metadata of the image of the instance.
|
|
:param disk_size: The size of disk to create. If the size is smaller
|
|
than the image, the image size will be used.
|
|
:param image_type: The image type. See disk/driver.py
|
|
"""
|
|
super(CreateDiskForImg, self).__init__(name='crt_disk_from_img',
|
|
provides='disk_dev_info')
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
self.image_meta = image_meta
|
|
self.disk_size = disk_size
|
|
self.image_type = image_type
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Creating disk for instance: %s'), self.instance.name)
|
|
return self.disk_dvr.create_disk_from_image(
|
|
self.context, self.instance, self.image_meta, self.disk_size,
|
|
image_type=self.image_type)
|
|
|
|
def revert(self, result, flow_failures):
|
|
# The parameters have to match the execute method, plus the response +
|
|
# failures even if only a subset are used.
|
|
LOG.warning(_LW('Image for instance %s to be deleted'),
|
|
self.instance.name)
|
|
|
|
# If there is no result, or its a direct failure, then there isn't
|
|
# anything to delete.
|
|
if result is None or isinstance(result, task_fail.Failure):
|
|
return
|
|
|
|
# Run the delete. The result is a single disk. Wrap into list
|
|
# as the method works with plural disks.
|
|
self.disk_dvr.delete_disks(self.context, self.instance, [result])
|
|
|
|
|
|
class ConnectDisk(task.Task):
|
|
"""The task to connect the disk to the instance."""
|
|
|
|
def __init__(self, disk_dvr, context, instance, stg_ftsk=None):
|
|
"""Create the Task for the connect disk to instance method.
|
|
|
|
Requires LPAR info through requirement of lpar_wrap.
|
|
|
|
Requires disk info through requirement of disk_dev_info (provided by
|
|
crt_disk_from_img)
|
|
|
|
:param disk_dvr: The disk driver.
|
|
:param context: The context passed into the spawn method.
|
|
:param instance: The nova instance.
|
|
:param stg_ftsk: (Optional) The pypowervm transaction FeedTask for the
|
|
I/O Operations. If provided, the Virtual I/O Server
|
|
mapping updates will be added to the FeedTask. This
|
|
defers the updates to some later point in time. If
|
|
the FeedTask is not provided, the updates will be run
|
|
immediately when the respective method is executed.
|
|
"""
|
|
super(ConnectDisk, self).__init__(name='connect_disk',
|
|
requires=['disk_dev_info'])
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
self.stg_ftsk = stg_ftsk
|
|
|
|
def execute(self, disk_dev_info,):
|
|
LOG.info(_LI('Connecting disk to instance: %s'), self.instance.name)
|
|
self.disk_dvr.connect_disk(self.context, self.instance, disk_dev_info,
|
|
stg_ftsk=self.stg_ftsk)
|
|
|
|
def revert(self, disk_dev_info, result, flow_failures):
|
|
LOG.warning(_LW('Disk image being disconnected from instance %s'),
|
|
self.instance.name)
|
|
# Note that the FeedTask is None - to force instant disconnect.
|
|
self.disk_dvr.disconnect_image_disk(self.context, self.instance)
|
|
|
|
|
|
class InstanceDiskToMgmt(task.Task):
|
|
"""Connect an instance's disk to the management partition, discover it.
|
|
|
|
We do these two pieces together because their reversion doesn't happen in
|
|
the opposite order.
|
|
"""
|
|
|
|
def __init__(self, disk_dvr, instance):
|
|
"""Create the Task for connecting boot disk to mgmt partition.
|
|
|
|
Provides:
|
|
stg_elem: The storage element wrapper (pypowervm LU, PV, etc.) that was
|
|
connected.
|
|
vios_wrap: The Virtual I/O Server wrapper
|
|
(pypowervm.wrappers.virtual_io_server.VIOS) from which the
|
|
storage element was mapped.
|
|
disk_path: The local path to the mapped-and-discovered device, e.g.
|
|
'/dev/sde'
|
|
|
|
:param disk_dvr: The disk driver.
|
|
:param instance: The nova instance whose boot disk is to be connected.
|
|
"""
|
|
super(InstanceDiskToMgmt, self).__init__(
|
|
name='connect_and_discover_instance_disk_to_mgmt',
|
|
provides=['stg_elem', 'vios_wrap', 'disk_path'])
|
|
self.disk_dvr = disk_dvr
|
|
self.instance = instance
|
|
self.stg_elem = None
|
|
self.vios_wrap = None
|
|
self.disk_path = None
|
|
|
|
def execute(self):
|
|
"""Map the instance's boot disk and discover it."""
|
|
LOG.info(_LI("Mapping boot disk of instance %(instance_name)s to "
|
|
"management partition."),
|
|
{'instance_name': self.instance.name})
|
|
self.stg_elem, self.vios_wrap = (
|
|
self.disk_dvr.connect_instance_disk_to_mgmt(self.instance))
|
|
new_maps = pvm_smap.find_maps(
|
|
self.vios_wrap.scsi_mappings, client_lpar_id=self.disk_dvr.mp_uuid,
|
|
stg_elem=self.stg_elem)
|
|
if not new_maps:
|
|
raise npvmex.NewMgmtMappingNotFoundException(
|
|
stg_name=self.stg_elem.name, vios_name=self.vios_wrap.name)
|
|
|
|
# new_maps should be length 1, but even if it's not - i.e. we somehow
|
|
# matched more than one mapping of the same dev to the management
|
|
# partition from the same VIOS - it is safe to use the first one.
|
|
the_map = new_maps[0]
|
|
# Scan the SCSI bus, discover the disk, find its canonical path.
|
|
LOG.info(_LI("Discovering device and path for mapping of %(dev_name)s "
|
|
"on the management partition."),
|
|
{'dev_name': self.stg_elem.name})
|
|
self.disk_path = mgmt.discover_vscsi_disk(the_map)
|
|
return self.stg_elem, self.vios_wrap, self.disk_path
|
|
|
|
def revert(self, result, flow_failures):
|
|
"""Unmap the disk and then remove it from the management partition.
|
|
|
|
We use this order to avoid rediscovering the device in case some other
|
|
thread scans the SCSI bus between when we remove and when we unmap.
|
|
"""
|
|
if self.vios_wrap is None or self.stg_elem is None:
|
|
# We never even got connected - nothing to do
|
|
return
|
|
LOG.warning(_LW("Unmapping boot disk %(disk_name)s of instance "
|
|
"%(instance_name)s from management partition via "
|
|
"Virtual I/O Server %(vios_name)s."),
|
|
{'disk_name': self.stg_elem.name,
|
|
'instance_name': self.instance.name,
|
|
'vios_name': self.vios_wrap.name})
|
|
self.disk_dvr.disconnect_disk_from_mgmt(self.vios_wrap.uuid,
|
|
self.stg_elem.name)
|
|
|
|
if self.disk_path is None:
|
|
# We did not discover the disk - nothing else to do.
|
|
return
|
|
LOG.warning(_LW("Removing disk %(disk_path)s from the management "
|
|
"partition."), {'disk_path': self.disk_path})
|
|
mgmt.remove_block_dev(self.disk_path)
|
|
|
|
|
|
class RemoveInstanceDiskFromMgmt(task.Task):
|
|
"""Unmap and remove an instance's boot disk from the mgmt partition."""
|
|
|
|
def __init__(self, disk_dvr, instance):
|
|
"""Unmap and remove an instance's boot disk from the mgmt partition.
|
|
|
|
Requires (from InstanceDiskToMgmt):
|
|
stg_elem: The storage element wrapper (pypowervm LU, PV, etc.) that was
|
|
connected.
|
|
vios_wrap: The Virtual I/O Server wrapper
|
|
(pypowervm.wrappers.virtual_io_server.VIOS) from which the
|
|
storage element was mapped.
|
|
disk_path: The local path to the mapped-and-discovered device, e.g.
|
|
'/dev/sde'
|
|
|
|
:param disk_dvr: The disk driver.
|
|
:param instance: The nova instance whose boot disk is to be connected.
|
|
"""
|
|
self.disk_dvr = disk_dvr
|
|
self.instance = instance
|
|
super(RemoveInstanceDiskFromMgmt, self).__init__(
|
|
name='remove_inst_disk_from_mgmt',
|
|
requires=['stg_elem', 'vios_wrap', 'disk_path'])
|
|
|
|
def execute(self, stg_elem, vios_wrap, disk_path):
|
|
"""Unmap and remove an instance's boot disk from the mgmt partition.
|
|
|
|
Input parameters ('requires') provided by InstanceDiskToMgmt task.
|
|
|
|
:param stg_elem: The storage element wrapper (pypowervm LU, PV, etc.)
|
|
to be disconnected.
|
|
:param vios_wrap: The Virtual I/O Server wrapper from which the
|
|
mapping is to be removed.
|
|
:param disk_path: The local path to the disk device to be removed, e.g.
|
|
'/dev/sde'
|
|
"""
|
|
LOG.info(_LI("Unmapping boot disk %(disk_name)s of instance "
|
|
"%(instance_name)s from management partition via Virtual "
|
|
"I/O Server %(vios_name)s."),
|
|
{'disk_name': stg_elem.name,
|
|
'instance_name': self.instance.name,
|
|
'vios_name': vios_wrap.name})
|
|
self.disk_dvr.disconnect_disk_from_mgmt(vios_wrap.uuid, stg_elem.name)
|
|
LOG.info(_LI("Removing disk %(disk_path)s from the management "
|
|
"partition."), {'disk_path': disk_path})
|
|
mgmt.remove_block_dev(disk_path)
|
|
|
|
|
|
class CreateAndConnectCfgDrive(task.Task):
|
|
"""The task to create the configuration drive."""
|
|
|
|
def __init__(self, adapter, host_uuid, instance, injected_files,
|
|
network_info, admin_pass, stg_ftsk=None):
|
|
"""Create the Task that create and connect the config drive.
|
|
|
|
Requires the 'lpar_wrap' and 'mgmt_cna'
|
|
Provides the 'cfg_drv_vscsi_map' which is an element to later map
|
|
the vscsi drive.
|
|
|
|
:param adapter: The adapter for the pypowervm API
|
|
:param host_uuid: The host UUID of the system.
|
|
:param instance: The nova instance
|
|
:param injected_files: A list of file paths that will be injected into
|
|
the ISO.
|
|
:param network_info: The network_info from the nova spawn method.
|
|
:param admin_pass: Optional password to inject for the VM.
|
|
:param stg_ftsk: (Optional) The pypowervm transaction FeedTask for the
|
|
I/O Operations. If provided, the Virtual I/O Server
|
|
mapping updates will be added to the FeedTask. This
|
|
defers the updates to some later point in time. If
|
|
the FeedTask is not provided, the updates will be run
|
|
immediately when the respective method is executed.
|
|
"""
|
|
super(CreateAndConnectCfgDrive, self).__init__(
|
|
name='cfg_drive', requires=['lpar_wrap', 'mgmt_cna'])
|
|
self.adapter = adapter
|
|
self.host_uuid = host_uuid
|
|
self.instance = instance
|
|
self.injected_files = injected_files
|
|
self.network_info = network_info
|
|
self.ad_pass = admin_pass
|
|
self.mb = None
|
|
self.stg_ftsk = stg_ftsk
|
|
|
|
def execute(self, lpar_wrap, mgmt_cna):
|
|
LOG.info(_LI('Creating Config Drive for instance: %s'),
|
|
self.instance.name)
|
|
self.mb = media.ConfigDrivePowerVM(self.adapter, self.host_uuid)
|
|
self.mb.create_cfg_drv_vopt(self.instance, self.injected_files,
|
|
self.network_info, lpar_wrap.uuid,
|
|
admin_pass=self.ad_pass,
|
|
mgmt_cna=mgmt_cna, stg_ftsk=self.stg_ftsk)
|
|
|
|
def revert(self, lpar_wrap, mgmt_cna, result, flow_failures):
|
|
# The parameters have to match the execute method, plus the response +
|
|
# failures even if only a subset are used.
|
|
|
|
# No media builder, nothing to do
|
|
if self.mb is None:
|
|
return
|
|
|
|
# Delete the virtual optical media
|
|
self.mb.dlt_vopt(lpar_wrap.uuid)
|
|
|
|
|
|
class DeleteVOpt(task.Task):
|
|
"""The task to delete the virtual optical."""
|
|
|
|
def __init__(self, adapter, host_uuid, instance, lpar_uuid,
|
|
stg_ftsk=None):
|
|
"""Creates the Task to delete the instances virtual optical media.
|
|
|
|
:param adapter: The adapter for the pypowervm API
|
|
:param host_uuid: The host UUID of the system.
|
|
:param instance: The nova instance.
|
|
:param lpar_uuid: The UUID of the lpar that has media.
|
|
:param stg_ftsk: (Optional) The pypowervm transaction FeedTask for the
|
|
I/O Operations. If provided, the Virtual I/O Server
|
|
mapping updates will be added to the FeedTask. This
|
|
defers the updates to some later point in time. If
|
|
the FeedTask is not provided, the updates will be run
|
|
immediately when the respective method is executed.
|
|
"""
|
|
super(DeleteVOpt, self).__init__(name='vopt_delete')
|
|
self.adapter = adapter
|
|
self.host_uuid = host_uuid
|
|
self.instance = instance
|
|
self.lpar_uuid = lpar_uuid
|
|
self.stg_ftsk = stg_ftsk
|
|
|
|
def execute(self):
|
|
media_builder = media.ConfigDrivePowerVM(self.adapter, self.host_uuid)
|
|
media_builder.dlt_vopt(self.lpar_uuid, stg_ftsk=self.stg_ftsk)
|
|
|
|
|
|
class DetachDisk(task.Task):
|
|
"""The task to detach the disk storage from the instance."""
|
|
|
|
def __init__(self, disk_dvr, context, instance, stg_ftsk=None,
|
|
disk_type=None):
|
|
"""Creates the Task to detach the storage adapters.
|
|
|
|
Provides the stor_adpt_mappings. A list of pypowervm
|
|
VSCSIMappings or VFCMappings (depending on the storage adapter).
|
|
|
|
:param disk_dvr: The DiskAdapter for the VM.
|
|
:param context: The nova context.
|
|
:param instance: The nova instance.
|
|
:param stg_ftsk: (Optional) The pypowervm transaction FeedTask for the
|
|
I/O Operations. If provided, the Virtual I/O Server
|
|
mapping updates will be added to the FeedTask. This
|
|
defers the updates to some later point in time. If
|
|
the FeedTask is not provided, the updates will be run
|
|
immediately when the respective method is executed.
|
|
:param disk_type: List of disk types to detach. None means detach all.
|
|
"""
|
|
super(DetachDisk, self).__init__(name='detach_storage',
|
|
provides='stor_adpt_mappings')
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
self.stg_ftsk = stg_ftsk
|
|
self.disk_type = disk_type
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Detaching disk storage adapters for instance %s'),
|
|
self.instance.name)
|
|
return self.disk_dvr.disconnect_image_disk(
|
|
self.context, self.instance, stg_ftsk=self.stg_ftsk,
|
|
disk_type=self.disk_type)
|
|
|
|
|
|
class DeleteDisk(task.Task):
|
|
"""The task to delete the backing storage."""
|
|
|
|
def __init__(self, disk_dvr, context, instance):
|
|
"""Creates the Task to delete the disk storage from the system.
|
|
|
|
Requires the stor_adpt_mappings.
|
|
|
|
:param disk_dvr: The DiskAdapter for the VM.
|
|
:param context: The nova context.
|
|
:param instance: The nova instance.
|
|
"""
|
|
req = ['stor_adpt_mappings']
|
|
super(DeleteDisk, self).__init__(name='dlt_storage', requires=req)
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
|
|
def execute(self, stor_adpt_mappings):
|
|
LOG.info(_LI('Deleting storage disk for instance %s.'),
|
|
self.instance.name)
|
|
self.disk_dvr.delete_disks(self.context, self.instance,
|
|
stor_adpt_mappings)
|
|
|
|
|
|
class SaveBDM(task.Task):
|
|
"""Task to save an updated block device mapping."""
|
|
|
|
def __init__(self, bdm, instance):
|
|
"""Creates the Task to save an updated block device mapping.
|
|
|
|
:param bdm: The updated bdm.
|
|
:param instance: The nova instance
|
|
"""
|
|
self.bdm = bdm
|
|
self.instance = instance
|
|
super(SaveBDM, self).__init__(name='save_bdm_%s' % self.bdm.volume_id)
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Saving block device mapping for volume id %(vol_id)s '
|
|
'on instance %(inst)s.'),
|
|
{'vol_id': self.bdm.volume_id, 'inst': self.instance.name})
|
|
self.bdm.save()
|
|
|
|
|
|
class FindDisk(task.Task):
|
|
"""The Task to find a disk and provide information to downstream tasks."""
|
|
|
|
def __init__(self, disk_dvr, context, instance, disk_type):
|
|
"""Create the Task.
|
|
|
|
Provides the 'disk_dev_info' for other tasks. Comes from the disk_dvr
|
|
create_disk_from_image method.
|
|
|
|
:param disk_dvr: The storage driver.
|
|
:param context: The context passed into the driver method.
|
|
:param instance: The nova instance.
|
|
:param disk_type: One of the DiskType enum values.
|
|
"""
|
|
super(FindDisk, self).__init__(name='find_disk',
|
|
provides='disk_dev_info')
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
self.disk_type = disk_type
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Finding disk for instance: %s'), self.instance.name)
|
|
disk = self.disk_dvr.get_disk_ref(self.instance, self.disk_type)
|
|
if not disk:
|
|
LOG.warning(_LW('Disk not found: %(disk_name)s'),
|
|
{'disk_name':
|
|
self.disk_dvr._get_disk_name(self.disk_type,
|
|
self.instance),
|
|
}, instance=self.instance)
|
|
return disk
|
|
|
|
|
|
class ExtendDisk(task.Task):
|
|
"""Task to extend a disk."""
|
|
|
|
def __init__(self, disk_dvr, context, instance, disk_info, size):
|
|
"""Creates the Task to extend a disk.
|
|
|
|
:param disk_dvr: The storage driver.
|
|
:param context: nova context for operation.
|
|
:param instance: instance to extend the disk for.
|
|
:param disk_info: dictionary with disk info.
|
|
:param size: the new size in gb.
|
|
"""
|
|
self.disk_dvr = disk_dvr
|
|
self.context = context
|
|
self.instance = instance
|
|
self.disk_info = disk_info
|
|
self.size = size
|
|
super(ExtendDisk, self).__init__(name='extend_disk_%s' %
|
|
disk_info['type'])
|
|
|
|
def execute(self):
|
|
LOG.info(_LI('Extending disk size of disk: %(disk)s size: %(size)s.'),
|
|
{'disk': self.disk_info['type'], 'size': self.size})
|
|
self.disk_dvr.extend_disk(self.context, self.instance, self.disk_info,
|
|
self.size)
|