emc_vmax_provision_v3.py

# Copyright (c) 2012 - 2014 EMC Corporation.
# 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.

import time

from cinder import exception
from cinder.i18n import _, _LE
from cinder.openstack.common import log as logging
from cinder.volume.drivers.emc import emc_vmax_utils

LOG = logging.getLogger(__name__)

STORAGEGROUPTYPE = 4
POSTGROUPTYPE = 3

EMC_ROOT = 'root/emc'
THINPROVISIONINGCOMPOSITE = 32768
THINPROVISIONING = 5


class EMCVMAXProvisionV3(object):
    """Provisioning Class for SMI-S based EMC volume drivers.

    This Provisioning class is for EMC volume drivers based on SMI-S.
    It supports VMAX arrays.
    """
    def __init__(self, prtcl):
        self.protocol = prtcl
        self.utils = emc_vmax_utils.EMCVMAXUtils(prtcl)

    def delete_volume_from_pool(
            self, conn, storageConfigservice, volumeInstanceName, volumeName):
        """Given the volume instance remove it from the pool.

        :param conn: connection the the ecom server
        :param storageConfigservice: volume created from job
        :param volumeInstanceName: the volume instance name
        :param volumeName: the volume name (String)
        :param
        :param rc: return code
        """
        startTime = time.time()

        if isinstance(volumeInstanceName, list):
            theElements = volumeInstanceName
            volumeName = 'Bulk Delete'
        else:
            theElements = [volumeInstanceName]

        rc, job = conn.InvokeMethod(
            'ReturnElementsToStoragePool', storageConfigservice,
            TheElements=theElements)

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(conn, job)
            if rc != 0L:
                exceptionMessage = (_(
                    "Error Delete Volume: %(volumeName)s.  "
                    "Return code: %(rc)lu.  Error: %(error)s")
                    % {'volumeName': volumeName,
                       'rc': rc,
                       'error': errordesc})
                LOG.error(exceptionMessage)
                raise exception.VolumeBackendAPIException(
                    data=exceptionMessage)

        LOG.debug("InvokeMethod ReturnElementsToStoragePool took: "
                  "%(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})

        return rc

    def create_volume_from_sg(
            self, conn, storageConfigService, volumeName,
            sgInstanceName, volumeSize):
        """Create the volume and associate it with a storage group

        We use EMCCollections parameter to supply a Device Masking Group
        to contain a newly created storage volume.

        :param conn: the connection information to the ecom server
        :param storageConfigService: the storage configuration service
        :param volumeName: the volume name (String)
        :param sgInstanceName: the storage group instance name
                                associated with an SLO
        :param volumeSize: volume size (String)
        :returns: volumeDict - the volume dict
        """
        startTime = time.time()

        rc, job = conn.InvokeMethod(
            'CreateOrModifyElementFromStoragePool',
            storageConfigService, ElementName=volumeName,
            EMCCollections=[sgInstanceName],
            ElementType=self.utils.get_num(THINPROVISIONING, '16'),
            Size=self.utils.get_num(volumeSize, '64'))

        LOG.debug("Create Volume: %(volumename)s  Return code: %(rc)lu",
                  {'volumename': volumeName,
                   'rc': rc})

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(conn, job)
            if rc != 0L:
                exceptionMessage = (_(
                    "Error Create Volume: %(volumeName)s.  "
                    "Return code: %(rc)lu.  Error: %(error)s")
                    % {'volumeName': volumeName,
                       'rc': rc,
                       'error': errordesc})
                LOG.error(exceptionMessage)
                raise exception.VolumeBackendAPIException(
                    data=exceptionMessage)

        LOG.debug("InvokeMethod CreateOrModifyElementFromStoragePool "
                  "took: %(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})

        # Find the newly created volume
        volumeDict = self.get_volume_dict_from_job(conn, job['Job'])
        return volumeDict, rc

    def _find_new_storage_group(
            self, conn, maskingGroupDict, storageGroupName):
        """After creating an new storage group find it and return it.

        :param conn: connection the ecom server
        :param maskingGroupDict: the maskingGroupDict dict
        :param storageGroupName: storage group name (String)
        :returns: maskingGroupDict['MaskingGroup']
        """
        foundStorageGroupInstanceName = None
        if 'MaskingGroup' in maskingGroupDict:
            foundStorageGroupInstanceName = maskingGroupDict['MaskingGroup']

        return foundStorageGroupInstanceName

    def get_volume_dict_from_job(self, conn, jobInstance):
        """Given the jobInstance determine the volume Instance.

        :param conn: the ecom connection
        :param jobInstance: the instance of a job
        :returns: volumeDict - an instance of a volume
        """
        associators = conn.Associators(
            jobInstance,
            ResultClass='EMC_StorageVolume')
        volpath = associators[0].path
        volumeDict = {}
        volumeDict['classname'] = volpath.classname
        keys = {}
        keys['CreationClassName'] = volpath['CreationClassName']
        keys['SystemName'] = volpath['SystemName']
        keys['DeviceID'] = volpath['DeviceID']
        keys['SystemCreationClassName'] = volpath['SystemCreationClassName']
        volumeDict['keybindings'] = keys

        return volumeDict

    def create_element_replica(
            self, conn, repServiceInstanceName,
            cloneName, syncType, sourceInstance, targetInstance=None):
        """Make SMI-S call to create replica for source element

        :param conn - the connection to the ecom server
        :param repServiceInstanceName - replication service
        :param cloneName - clone volume name
        :param syncType - 7: snapshot, 8: clone
        :param sourceInstance - source volume instance
        :param targetInstance - target volume instance
        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        startTime = time.time()

        if targetInstance is None:
            LOG.debug("Create targetless replica: %(clone)s "
                      "syncType: %(syncType)s  Source: %(source)s",
                      {'clone': cloneName,
                       'syncType': syncType,
                       'source': sourceInstance.path})
            rc, job = conn.InvokeMethod(
                'CreateElementReplica', repServiceInstanceName,
                ElementName=cloneName, SyncType=syncType,
                SourceElement=sourceInstance.path)
        else:
            LOG.debug(
                "Create replica: %(clone)s syncType: %(syncType)s "
                "Source: %(source)s target: %(target)s",
                {'clone': cloneName,
                 'syncType': syncType,
                 'source': sourceInstance.path,
                 'target': targetInstance.path})
            rc, job = conn.InvokeMethod(
                'CreateElementReplica', repServiceInstanceName,
                ElementName=cloneName, SyncType=syncType,
                SourceElement=sourceInstance.path,
                TargetElement=targetInstance.path)

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(conn, job)
            if rc != 0L:
                exceptionMessage = (_(
                    "Error Create Cloned Volume: %(cloneName)s  "
                    "Return code: %(rc)lu. Error: %(error)s")
                    % {'cloneName': cloneName,
                       'rc': rc,
                       'error': errordesc})
                LOG.error(exceptionMessage)
                raise exception.VolumeBackendAPIException(
                    data=exceptionMessage)

        LOG.debug("InvokeMethod CreateElementReplica "
                  "took: %(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})
        return rc, job

    def break_replication_relationship(
            self, conn, repServiceInstanceName, syncInstanceName,
            operation, force=False):
        """Deletes the relationship between the clone/snap and source volume.

        Makes an SMI-S call to break clone relationship between the clone
        volume and the source

        :param conn: the connection to the ecom server
        :param repServiceInstanceName: instance name of the replication service
        :param syncInstanceName: instance name of the
                                 SE_StorageSynchronized_SV_SV object
        :param cloneName: replica name
        :param sourceName: source volume name
        :param sourceInstance: source volume instance
        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        LOG.debug("Break replication relationship: %(sv)s  "
                  "operation: %(operation)s",
                  {'sv': syncInstanceName, 'operation': operation})

        return self._modify_replica_synchronization(
            conn, repServiceInstanceName, syncInstanceName, operation, force)

    def create_storage_group_v3(self, conn, controllerConfigService,
                                groupName, srp, slo, workload):
        """Create the volume in the specified pool.

        :param conn: the connection information to the ecom server
        :param controllerConfigService: the controller configuration service
        :param groupName: the group name (String)
        :param srp: the SRP (String)
        :param slo: the SLO (String)
        :param workload: the workload (String)
        :returns: volumeDict - the volume dict

        """
        startTime = time.time()

        rc, job = conn.InvokeMethod(
            'CreateGroup',
            controllerConfigService,
            GroupName=groupName,
            Type=self.utils.get_num(4, '16'),
            EMCSRP=srp,
            EMCSLO=slo,
            EMCWorkload=workload)

        if rc != 0L:
            rc, errordesc = rc, errordesc = self.utils.wait_for_job_complete(
                conn, job)
            if rc != 0L:
                LOG.error(_LE(
                    'Error Create Group: %(groupName)s.  '
                    'Return code: %(rc)lu.  Error: %(error)s'),
                    {'groupName': groupName,
                     'rc': rc,
                     'error': errordesc})
                raise

        LOG.debug("InvokeMethod CreateGroup "
                  "took: %(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})

        foundStorageGroupInstanceName = self._find_new_storage_group(
            conn, job, groupName)

        return foundStorageGroupInstanceName

    def _get_storage_pool_capability(self, conn, poolInstanceName):
        """get the pool capability.

        :param conn: the connection information to the ecom server
        :param poolInstanceName: the pool instance
        :returns: storagePoolCapability - the storage pool capability instance
        """
        storagePoolCapability = None

        associators = (
            conn.AssociatorNames(poolInstanceName,
                                 ResultClass='Symm_StoragePoolCapabilities'))

        if len(associators) > 0:
            storagePoolCapability = associators[0]

        return storagePoolCapability

    def _get_storage_pool_setting(
            self, conn, storagePoolCapability, slo, workload):
        """get the pool setting for pool capability.

        :param conn: the connection information to the ecom server
        :param storagePoolCapability: the storage pool capability instance
        :param slo: the slo string e.g Bronze
        :param workload: the workload string e.g DSS_REP
        :returns: foundStoragePoolSetting - the storage pool setting instance
        """

        foundStoragePoolSetting = None
        storagePoolSettings = (
            conn.AssociatorNames(storagePoolCapability,
                                 ResultClass='CIM_storageSetting'))

        for storagePoolSetting in storagePoolSettings:
            settingInstanceID = storagePoolSetting['InstanceID']
            matchString = slo + ':' + workload
            if matchString in settingInstanceID:
                foundStoragePoolSetting = storagePoolSetting
                break
        return foundStoragePoolSetting

    # New
    # GetSupportedSizes, GetSupportedSizeRange updated to return
    # SLO headroom information.
    def _get_supported_size_range_for_SLO(
            self, conn, storageConfigService,
            srpPoolInstanceName, storagePoolSettingInstanceName):
        """Gets available performance capacity per SLO.

        :param conn: the connection information to the ecom server
        :param srpPoolInstanceName: the SRP storage pool instance
        :param storagePoolSettingInstanceName: the SLO type
                                e.g Bronze
        :returns: volumeDict - the volume dict
        """
        startTime = time.time()

        rc, supportedSizeDict = conn.InvokeMethod(
            'GetSupportedSizeRange',
            srpPoolInstanceName,
            ElementType=self.utils.get_num(3, '16'),
            Goal=storagePoolSettingInstanceName)

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(
                conn, supportedSizeDict)
            if rc != 0L:
                exceptionMessage = (_(
                    "Cannot get supported size range for %(sps)s "
                    "Return code: %(rc)lu.  Error: %(error)s")
                    % {'sps': storagePoolSettingInstanceName,
                       'rc': rc,
                       'error': errordesc})
                LOG.error(exceptionMessage)
                raise exception.VolumeBackendAPIException(
                    data=exceptionMessage)

        LOG.debug("InvokeMethod GetSupportedSizeRange "
                  "took: %(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})

        return supportedSizeDict

    def get_volume_range(
            self, conn, storageConfigService, poolInstanceName, slo, workload):
        """get upper and lower range for volume for slo/workload combination

        :param conn: the connection information to the ecom server
        :param storageConfigService: the storage config service
        :param poolInstanceName: the pool instance
        :param volumeSize: volume size (bits)
        :param slo: slo string e.g Bronze
        :param workload: workload string e.g DSS
        :returns: storagePoolCapability - the storage pool capability instance
        """
        maximumVolumeSize = None
        minimumVolumeSize = None

        storagePoolCapabilityInstanceName = self._get_storage_pool_capability(
            conn, poolInstanceName)
        if storagePoolCapabilityInstanceName:
            storagePoolSettingInstanceName = self._get_storage_pool_setting(
                conn, storagePoolCapabilityInstanceName, slo, workload)
            if storagePoolCapabilityInstanceName:
                supportedSizeDict = self._get_supported_size_range_for_SLO(
                    conn, storageConfigService, poolInstanceName,
                    storagePoolSettingInstanceName)

                maximumVolumeSize = supportedSizeDict['MaximumVolumeSize']
                minimumVolumeSize = supportedSizeDict['MinimumVolumeSize']

        return maximumVolumeSize, minimumVolumeSize

    def activate_snap_relationship(
            self, conn, repServiceInstanceName, syncInstanceName):
        """Activate snap relationship and start copy operation.

        :param conn: the connection to the ecom server
        :param repServiceInstanceName: instance name of the replication service
        :param syncInstanceName: instance name of the
                                 SE_StorageSynchronized_SV_SV object
        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        # operation 4: activate the snapVx
        operation = self.utils.get_num(4, '16')

        LOG.debug("Activate snap: %(sv)s  operation: %(operation)s ",
                  {'sv': syncInstanceName, 'operation': operation})

        return self._modify_replica_synchronization(
            conn, repServiceInstanceName, syncInstanceName, operation)

    def return_to_resource_pool(self, conn, repServiceInstanceName,
                                syncInstanceName):
        """return the snap target resources back to the pool

        :param conn: the connection to the ecom server
        :param repServiceInstanceName: instance name of the replication service
        :param syncInstanceName: instance name of the
        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        # operation 4: activate the snapVx
        operation = self.utils.get_num(19, '16')

        LOG.debug("Return snap resource back to pool: "
                  "%(sv)s  operation: %(operation)s ",
                  {'sv': syncInstanceName, 'operation': operation})

        return self._modify_replica_synchronization(
            conn, repServiceInstanceName, syncInstanceName, operation)

    def _modify_replica_synchronization(
            self, conn, repServiceInstanceName, syncInstanceName,
            operation, force=False):
        """Helper function to modify the relationship between the clone/snap
        and source volume.

        Makes an SMI-S call to break clone relationship between the clone
        volume and the source

        :param conn: the connection to the ecom server
        :param repServiceInstanceName: instance name of the replication service
        :param syncInstanceName: instance name of the
                                 SE_StorageSynchronized_SV_SV object
        :param cloneName: replica name
        :param sourceName: source volume name
        :param sourceInstance: source volume instance
        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        startTime = time.time()

        rc, job = conn.InvokeMethod(
            'ModifyReplicaSynchronization', repServiceInstanceName,
            Operation=operation,
            Synchronization=syncInstanceName,
            Force=force)

        LOG.debug("_modify_replica_synchronization: %(sv)s  "
                  "operation: %(operation)s  Return code: %(rc)lu",
                  {'sv': syncInstanceName, 'operation': operation, 'rc': rc})

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(conn, job)
            if rc != 0L:
                exceptionMessage = (_(
                    "Error modify replica synchronization: %(sv)s  "
                    "operation: %(operation)s.  "
                    "Return code: %(rc)lu.  Error: %(error)s")
                    % {'sv': syncInstanceName, 'operation': operation,
                       'rc': rc, 'error': errordesc})
                LOG.error(exceptionMessage)
                raise exception.VolumeBackendAPIException(
                    data=exceptionMessage)

        LOG.debug("InvokeMethod ModifyReplicaSynchronization "
                  "took: %(delta)s H:MM:SS",
                  {'delta': self.utils.get_time_delta(startTime,
                                                      time.time())})

        return rc, job

    def create_group_replica(
            self, conn, replicationService,
            srcGroupInstanceName, tgtGroupInstanceName, relationName):
        """Make SMI-S call to create replica for source group

        :param conn - the connection to the ecom server
        :param repServiceInstanceName - replication service
        :param srcGroupInstanceName - source group instance name
        :param tgtGroupInstanceName - target group instance name
        :param cgName - target group name

        :returns: rc - return code
        :returns: job - job object of the replica creation operation
        """
        LOG.debug(
            "Creating CreateGroupReplica V3: "
            "replicationService: %(replicationService)s  "
            "RelationName: %(relationName)s "
            "sourceGroup: %(srcGroup)s "
            "targetGroup: %(tgtGroup)s ",
            {'replicationService': replicationService,
             'relationName': relationName,
             'srcGroup': srcGroupInstanceName,
             'tgtGroup': tgtGroupInstanceName})
        # 7 for snap
        syncType = 7
        rc, job = conn.InvokeMethod(
            'CreateGroupReplica',
            replicationService,
            RelationshipName=relationName,
            SourceGroup=srcGroupInstanceName,
            TargetGroup=tgtGroupInstanceName,
            SyncType=self.utils.get_num(syncType, '16'))

        if rc != 0L:
            rc, errordesc = self.utils.wait_for_job_complete(conn, job)
            if rc != 0L:
                exceptionMsg = (_("Error CreateGroupReplica: "
                                  "source: %(source)s target: %(target)s."
                                  "Return code: %(rc)lu. Error: %(error)s")
                                % {'source': srcGroupInstanceName,
                                   'target': tgtGroupInstanceName,
                                   'rc': rc,
                                   'error': errordesc})
                LOG.error(exceptionMsg)
                raise exception.VolumeBackendAPIException(data=exceptionMsg)
        return rc, job