text: # Copyright (c) 2017 Dell Inc. or its subsidiaries.
  # 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 copy import deepcopy
  import datetime
  import hashlib
  import re
  
  from cinder.objects.group import Group
  from oslo_log import log as logging
  from oslo_utils import strutils
  import six
  
  from cinder import exception
  from cinder.i18n import _
  from cinder.objects import fields
  from cinder.volume import utils as vol_utils
  from cinder.volume import volume_types
  
  
  LOG = logging.getLogger(__name__)
  # SHARED CONSTANTS
  ISCSI = 'iscsi'
  FC = 'fc'
  INTERVAL = 'interval'
  RETRIES = 'retries'
  VOLUME_ELEMENT_NAME_PREFIX = 'OS-'
  VMAX_AFA_MODELS = ['VMAX250F', 'VMAX450F', 'VMAX850F', 'VMAX950F']
  MAX_SRP_LENGTH = 16
  TRUNCATE_5 = 5
  TRUNCATE_27 = 27
  
  ARRAY = 'array'
  SLO = 'slo'
  WORKLOAD = 'workload'
  SRP = 'srp'
  PORTGROUPNAME = 'storagetype:portgroupname'
  DEVICE_ID = 'device_id'
  INITIATOR_CHECK = 'initiator_check'
  SG_NAME = 'storagegroup_name'
  MV_NAME = 'maskingview_name'
  IG_NAME = 'init_group_name'
  PARENT_SG_NAME = 'parent_sg_name'
  CONNECTOR = 'connector'
  VOL_NAME = 'volume_name'
  EXTRA_SPECS = 'extra_specs'
  HOST_NAME = 'short_host_name'
  IS_RE = 'replication_enabled'
  DISABLECOMPRESSION = 'storagetype:disablecompression'
  REP_SYNC = 'Synchronous'
  REP_ASYNC = 'Asynchronous'
  REP_METRO = 'Metro'
  REP_MODE = 'rep_mode'
  RDF_SYNC_STATE = 'synchronized'
  RDF_SYNCINPROG_STATE = 'syncinprog'
  RDF_CONSISTENT_STATE = 'consistent'
  RDF_SUSPENDED_STATE = 'suspended'
  RDF_FAILEDOVER_STATE = 'failed over'
  RDF_ACTIVE = 'active'
  RDF_ACTIVEACTIVE = 'activeactive'
  RDF_ACTIVEBIAS = 'activebias'
  METROBIAS = 'metro_bias'
  DEFAULT_PORT = 8443
  CLONE_SNAPSHOT_NAME = "snapshot_for_clone"
  
  # Multiattach constants
  IS_MULTIATTACH = 'multiattach'
  OTHER_PARENT_SG = 'other_parent_sg_name'
  FAST_SG = 'fast_managed_sg'
  NO_SLO_SG = 'no_slo_sg'
  
  # Cinder.conf vmax configuration
  VMAX_SERVER_IP = 'san_ip'
  VMAX_USER_NAME = 'san_login'
  VMAX_PASSWORD = 'san_password'
  VMAX_SERVER_PORT_NEW = 'san_api_port'
  VMAX_SERVER_PORT_OLD = 'san_rest_port'
  VMAX_ARRAY = 'vmax_array'
  VMAX_WORKLOAD = 'vmax_workload'
  VMAX_SRP = 'vmax_srp'
  VMAX_SERVICE_LEVEL = 'vmax_service_level'
  VMAX_PORT_GROUPS = 'vmax_port_groups'
  VMAX_SNAPVX_UNLINK_LIMIT = 'vmax_snapvx_unlink_limit'
  
  
  class VMAXUtils(object):
      """Utility class for Rest based VMAX volume drivers.
  
      This Utility class is for VMAX volume drivers based on Unisphere Rest API.
      """
  
      def __init__(self):
          """Utility class for Rest based VMAX volume drivers."""
  
      def get_host_short_name(self, host_name):
          """Returns the short name for a given qualified host name.
  
          Checks the host name to see if it is the fully qualified host name
          and returns part before the dot. If there is no dot in the host name
          the full host name is returned.
          :param host_name: the fully qualified host name
          :returns: string -- the short host_name
          """
          host_array = host_name.split('.')
          if len(host_array) > 1:
              short_host_name = host_array[0]
          else:
              short_host_name = host_name
  
          return self.generate_unique_trunc_host(short_host_name)
  
      @staticmethod
      def get_volumetype_extra_specs(volume, volume_type_id=None):
          """Gets the extra specs associated with a volume type.
  
          :param volume: the volume dictionary
          :param volume_type_id: Optional override for volume.volume_type_id
          :returns: dict -- extra_specs - the extra specs
          :raises: VolumeBackendAPIException
          """
          extra_specs = {}
  
          try:
              if volume_type_id:
                  type_id = volume_type_id
              else:
                  type_id = volume.volume_type_id
              if type_id is not None:
                  extra_specs = volume_types.get_volume_type_extra_specs(type_id)
          except Exception as e:
              LOG.debug('Exception getting volume type extra specs: %(e)s',
                        {'e': six.text_type(e)})
          return extra_specs
  
      @staticmethod
      def get_short_protocol_type(protocol):
          """Given the protocol type, return I for iscsi and F for fc.
  
          :param protocol: iscsi or fc
          :returns: string -- 'I' for iscsi or 'F' for fc
          """
          if protocol.lower() == ISCSI.lower():
              return 'I'
          elif protocol.lower() == FC.lower():
              return 'F'
          else:
              return protocol
  
      @staticmethod
      def truncate_string(str_to_truncate, max_num):
          """Truncate a string by taking first and last characters.
  
          :param str_to_truncate: the string to be truncated
          :param max_num: the maximum number of characters
          :returns: string -- truncated string or original string
          """
          if len(str_to_truncate) > max_num:
              new_num = len(str_to_truncate) - max_num // 2
              first_chars = str_to_truncate[:max_num // 2]
              last_chars = str_to_truncate[new_num:]
              str_to_truncate = first_chars + last_chars
          return str_to_truncate
  
      @staticmethod
      def get_time_delta(start_time, end_time):
          """Get the delta between start and end time.
  
          :param start_time: the start time
          :param end_time: the end time
          :returns: string -- delta in string H:MM:SS
          """
          delta = end_time - start_time
          return six.text_type(datetime.timedelta(seconds=int(delta)))
  
      def get_default_storage_group_name(
              self, srp_name, slo, workload, is_compression_disabled=False,
              is_re=False, rep_mode=None):
          """Determine default storage group from extra_specs.
  
          :param srp_name: the name of the srp on the array
          :param slo: the service level string e.g Bronze
          :param workload: the workload string e.g DSS
          :param is_compression_disabled:  flag for disabling compression
          :param is_re: flag for replication
          :param rep_mode: flag to indicate replication mode
          :returns: storage_group_name
          """
          if slo and workload:
              prefix = ("OS-%(srpName)s-%(slo)s-%(workload)s"
                        % {'srpName': srp_name, 'slo': slo,
                           'workload': workload})
  
              if is_compression_disabled:
                  prefix += "-CD"
  
          else:
              prefix = "OS-no_SLO"
          if is_re:
              prefix += self.get_replication_prefix(rep_mode)
  
          storage_group_name = ("%(prefix)s-SG" % {'prefix': prefix})
          return storage_group_name
  
      @staticmethod
      def get_volume_element_name(volume_id):
          """Get volume element name follows naming convention, i.e. 'OS-UUID'.
  
          :param volume_id: Openstack volume ID containing uuid
          :returns: volume element name in format of OS-UUID
          """
          element_name = volume_id
          uuid_regex = (re.compile(
              r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}',
              re.I))
          match = uuid_regex.search(volume_id)
          if match:
              volume_uuid = match.group()
              element_name = ("%(prefix)s%(volumeUUID)s"
                              % {'prefix': VOLUME_ELEMENT_NAME_PREFIX,
                                 'volumeUUID': volume_uuid})
              LOG.debug(
                  "get_volume_element_name elementName:  %(elementName)s.",
                  {'elementName': element_name})
          return element_name
  
      @staticmethod
      def modify_snapshot_prefix(snapshot_name, manage=False, unmanage=False):
          """Modify a Snapshot prefix on VMAX backend.
  
          Prepare a snapshot name for manage/unmanage snapshot process either
          by adding or removing 'OS-' prefix.
  
          :param snapshot_name: the old snapshot backend display name
          :param manage: (bool) if the operation is managing a snapshot
          :param unmanage: (bool) if the operation is unmanaging a snapshot
          :return: snapshot name ready for backend VMAX assignment
          """
          new_snap_name = None
          if manage:
              new_snap_name = ("%(prefix)s%(snapshot_name)s"
                               % {'prefix': 'OS-',
                                  'snapshot_name': snapshot_name})
  
          if unmanage:
              snap_split = snapshot_name.split("-", 1)
              if snap_split[0] == 'OS':
                  new_snap_name = snap_split[1]
  
          return new_snap_name
  
      def generate_unique_trunc_host(self, host_name):
          """Create a unique short host name under 16 characters.
  
          :param host_name: long host name
          :returns: truncated host name
          """
          if host_name and len(host_name) > 16:
              host_name = host_name.lower()
              m = hashlib.md5()
              m.update(host_name.encode('utf-8'))
              uuid = m.hexdigest()
              new_name = ("%(host)s%(uuid)s"
                          % {'host': host_name[-6:],
                             'uuid': uuid})
              host_name = self.truncate_string(new_name, 16)
          return host_name
  
      def get_pg_short_name(self, portgroup_name):
          """Create a unique port group name under 12 characters.
  
          :param portgroup_name: long portgroup_name
          :returns: truncated portgroup_name
          """
          if portgroup_name and len(portgroup_name) > 12:
              portgroup_name = portgroup_name.lower()
              m = hashlib.md5()
              m.update(portgroup_name.encode('utf-8'))
              uuid = m.hexdigest()
              new_name = ("%(pg)s%(uuid)s"
                          % {'pg': portgroup_name[-6:],
                             'uuid': uuid})
              portgroup_name = self.truncate_string(new_name, 12)
          return portgroup_name
  
      @staticmethod
      def get_default_oversubscription_ratio(max_over_sub_ratio):
          """Override ratio if necessary.
  
          The over subscription ratio will be overridden if the user supplied
          max oversubscription ratio is less than 1.
          :param max_over_sub_ratio: user supplied over subscription ratio
          :returns: max_over_sub_ratio
          """
          if max_over_sub_ratio < 1.0:
              LOG.info("The user supplied value for max_over_subscription "
                       "ratio is less than 1.0. Using the default value of "
                       "20.0 instead...")
              max_over_sub_ratio = 20.0
          return max_over_sub_ratio
  
      def get_temp_snap_name(self, source_device_id):
          """Construct a temporary snapshot name for clone operation
  
          :param source_device_id: the source device id
          :return: snap_name
          """
          snap_name = ("temp-%(device)s-%(snap_name)s"
                       % {'device': source_device_id,
                          'snap_name': CLONE_SNAPSHOT_NAME})
          return snap_name
  
      @staticmethod
      def get_array_and_device_id(volume, external_ref):
          """Helper function for manage volume to get array name and device ID.
  
          :param volume: volume object from API
          :param external_ref: the existing volume object to be manged
          :returns: string value of the array name and device ID
          """
          device_id = external_ref.get(u'source-name', None)
          LOG.debug("External_ref: %(er)s", {'er': external_ref})
          if not device_id:
              device_id = external_ref.get(u'source-id', None)
          host = volume.host
          host_list = host.split('+')
          array = host_list[(len(host_list) - 1)]
  
          if device_id:
              if len(device_id) != 5:
                  error_message = (_("Device ID: %(device_id)s is invalid. "
                                     "Device ID should be exactly 5 digits.") %
                                   {'device_id': device_id})
                  LOG.error(error_message)
                  raise exception.VolumeBackendAPIException(
                      message=error_message)
              LOG.debug("Get device ID of existing volume - device ID: "
                        "%(device_id)s, Array: %(array)s.",
                        {'device_id': device_id,
                         'array': array})
          else:
              exception_message = (_("Source volume device ID is required."))
              raise exception.VolumeBackendAPIException(
                  message=exception_message)
          return array, device_id
  
      @staticmethod
      def is_compression_disabled(extra_specs):
          """Check is compression is to be disabled.
  
          :param extra_specs: extra specifications
          :returns: boolean
          """
          do_disable_compression = False
          if DISABLECOMPRESSION in extra_specs:
              if strutils.bool_from_string(extra_specs[DISABLECOMPRESSION]):
                  do_disable_compression = True
          return do_disable_compression
  
      def change_compression_type(self, is_source_compr_disabled, new_type):
          """Check if volume type have different compression types
  
          :param is_source_compr_disabled: from source
          :param new_type: from target
          :returns: boolean
          """
          extra_specs = new_type['extra_specs']
          is_target_compr_disabled = self.is_compression_disabled(extra_specs)
          if is_target_compr_disabled == is_source_compr_disabled:
              return False
          else:
              return True
  
      def change_replication(self, vol_is_replicated, new_type):
          """Check if volume types have different replication status.
  
          :param vol_is_replicated: from source
          :param new_type: from target
          :return: bool
          """
          is_tgt_rep = self.is_replication_enabled(new_type['extra_specs'])
          return vol_is_replicated != is_tgt_rep
  
      @staticmethod
      def is_replication_enabled(extra_specs):
          """Check if replication is to be enabled.
  
          :param extra_specs: extra specifications
          :returns: bool - true if enabled, else false
          """
          replication_enabled = False
          if IS_RE in extra_specs:
              replication_enabled = True
          return replication_enabled
  
      @staticmethod
      def get_replication_config(rep_device_list):
          """Gather necessary replication configuration info.
  
          :param rep_device_list: the replication device list from cinder.conf
          :returns: rep_config, replication configuration dict
          """
          rep_config = {}
          if not rep_device_list:
              return None
          else:
              target = rep_device_list[0]
              try:
                  rep_config['array'] = target['target_device_id']
                  rep_config['srp'] = target['remote_pool']
                  rep_config['rdf_group_label'] = target['rdf_group_label']
                  rep_config['portgroup'] = target['remote_port_group']
  
              except KeyError as ke:
                  error_message = (_("Failed to retrieve all necessary SRDF "
                                     "information. Error received: %(ke)s.") %
                                   {'ke': six.text_type(ke)})
                  LOG.exception(error_message)
                  raise exception.VolumeBackendAPIException(
                      message=error_message)
  
              allow_extend = target.get('allow_extend', 'false')
              if strutils.bool_from_string(allow_extend):
                  rep_config['allow_extend'] = True
              else:
                  rep_config['allow_extend'] = False
  
              rep_mode = target.get('mode', '')
              if rep_mode.lower() in ['async', 'asynchronous']:
                  rep_config['mode'] = REP_ASYNC
              elif rep_mode.lower() == 'metro':
                  rep_config['mode'] = REP_METRO
                  metro_bias = target.get('metro_use_bias', 'false')
                  if strutils.bool_from_string(metro_bias):
                      rep_config[METROBIAS] = True
                  else:
                      rep_config[METROBIAS] = False
                  allow_delete_metro = target.get('allow_delete_metro', 'false')
                  if strutils.bool_from_string(allow_delete_metro):
                      rep_config['allow_delete_metro'] = True
                  else:
                      rep_config['allow_delete_metro'] = False
              else:
                  rep_config['mode'] = REP_SYNC
  
          return rep_config
  
      @staticmethod
      def is_volume_failed_over(volume):
          """Check if a volume has been failed over.
  
          :param volume: the volume object
          :returns: bool
          """
          if volume is not None:
              if volume.get('replication_status') and (
                  volume.replication_status ==
                      fields.ReplicationStatus.FAILED_OVER):
                      return True
          return False
  
      @staticmethod
      def update_volume_model_updates(volume_model_updates,
                                      volumes, group_id, status='available'):
          """Update the volume model's status and return it.
  
          :param volume_model_updates: list of volume model update dicts
          :param volumes: volumes object api
          :param group_id: consistency group id
          :param status: string value reflects the status of the member volume
          :returns: volume_model_updates - updated volumes
          """
          LOG.info("Updating status for group: %(id)s.", {'id': group_id})
          if volumes:
              for volume in volumes:
                  volume_model_updates.append({'id': volume.id,
                                               'status': status})
          else:
              LOG.info("No volume found for group: %(cg)s.", {'cg': group_id})
          return volume_model_updates
  
      @staticmethod
      def get_grp_volume_model_update(volume, volume_dict, group_id):
          """Create and return the volume model update on creation.
  
          :param volume: volume object
          :param volume_dict: the volume dict
          :param group_id: consistency group id
          :returns: model_update
          """
          LOG.info("Updating status for group: %(id)s.", {'id': group_id})
          model_update = ({'id': volume.id, 'status': 'available',
                           'provider_location': six.text_type(volume_dict)})
          return model_update
  
      @staticmethod
      def update_extra_specs(extraspecs):
          """Update extra specs.
  
          :param extraspecs: the additional info
          :returns: extraspecs
          """
          try:
              pool_details = extraspecs['pool_name'].split('+')
              extraspecs[SLO] = pool_details[0]
              if len(pool_details) == 4:
                  extraspecs[WORKLOAD] = pool_details[1]
                  extraspecs[SRP] = pool_details[2]
                  extraspecs[ARRAY] = pool_details[3]
              else:
                  # Assume no workload given in pool name
                  extraspecs[SRP] = pool_details[1]
                  extraspecs[ARRAY] = pool_details[2]
                  extraspecs[WORKLOAD] = 'NONE'
          except KeyError:
              LOG.error("Error parsing SLO, workload from"
                        " the provided extra_specs.")
          return extraspecs
  
      def get_volume_group_utils(self, group, interval, retries):
          """Standard utility for generic volume groups.
  
          :param group: the generic volume group object to be created
          :param interval: Interval in seconds between retries
          :param retries: Retry count
          :returns: array, intervals_retries_dict
          :raises: VolumeBackendAPIException
          """
          arrays = set()
          # Check if it is a generic volume group instance
          if isinstance(group, Group):
              for volume_type in group.volume_types:
                  extra_specs = self.update_extra_specs(volume_type.extra_specs)
                  arrays.add(extra_specs[ARRAY])
          else:
              msg = (_("Unable to get volume type ids."))
              LOG.error(msg)
              raise exception.VolumeBackendAPIException(message=msg)
  
          if len(arrays) != 1:
              if not arrays:
                  msg = (_("Failed to get an array associated with "
                           "volume group: %(groupid)s.")
                         % {'groupid': group.id})
              else:
                  msg = (_("There are multiple arrays "
                           "associated with volume group: %(groupid)s.")
                         % {'groupid': group.id})
              LOG.error(msg)
              raise exception.VolumeBackendAPIException(message=msg)
          array = arrays.pop()
          intervals_retries_dict = {INTERVAL: interval, RETRIES: retries}
          return array, intervals_retries_dict
  
      def update_volume_group_name(self, group):
          """Format id and name consistency group.
  
          :param group: the generic volume group object
          :returns: group_name -- formatted name + id
          """
          group_name = ""
          if group.name is not None and group.name != group.id:
              group_name = (
                  self.truncate_string(
                      group.name, TRUNCATE_27) + "_")
  
          group_name += group.id
          return group_name
  
      @staticmethod
      def add_legacy_pools(pools):
          """Add legacy pools to allow extending a volume after upgrade.
  
          :param pools: the pool list
          :return: pools - the updated pool list
          """
          extra_pools = []
          for pool in pools:
              if 'none' in pool['pool_name'].lower():
                  extra_pools.append(pool)
          for pool in extra_pools:
              try:
                  slo = pool['pool_name'].split('+')[0]
                  srp = pool['pool_name'].split('+')[2]
                  array = pool['pool_name'].split('+')[3]
              except IndexError:
                  slo = pool['pool_name'].split('+')[0]
                  srp = pool['pool_name'].split('+')[1]
                  array = pool['pool_name'].split('+')[2]
              new_pool_name = ('%(slo)s+%(srp)s+%(array)s'
                               % {'slo': slo, 'srp': srp, 'array': array})
              new_pool = deepcopy(pool)
              new_pool['pool_name'] = new_pool_name
              pools.append(new_pool)
          return pools
  
      def check_replication_matched(self, volume, extra_specs):
          """Check volume type and group type.
  
          This will make sure they do not conflict with each other.
  
          :param volume: volume to be checked
          :param extra_specs: the extra specifications
          :raises: InvalidInput
          """
          # If volume is not a member of group, skip this check anyway.
          if not volume.group:
              return
          vol_is_re = self.is_replication_enabled(extra_specs)
          group_is_re = volume.group.is_replicated
  
          if not (vol_is_re == group_is_re):
              msg = _('Replication should be enabled or disabled for both '
                      'volume or group. Volume replication status: '
                      '%(vol_status)s, group replication status: '
                      '%(group_status)s') % {
                          'vol_status': vol_is_re, 'group_status': group_is_re}
              raise exception.InvalidInput(reason=msg)
  
      @staticmethod
      def check_rep_status_enabled(group):
          """Check replication status for group.
  
          Group status must be enabled before proceeding with certain
          operations.
  
          :param group: the group object
          :raises: InvalidInput
          """
          if group.is_replicated:
              if group.replication_status != fields.ReplicationStatus.ENABLED:
                  msg = (_('Replication status should be %s for '
                           'replication-enabled group.')
                         % fields.ReplicationStatus.ENABLED)
                  LOG.error(msg)
                  raise exception.InvalidInput(reason=msg)
          else:
              LOG.debug('Replication is not enabled on group %s, '
                        'skip status check.', group.id)
  
      @staticmethod
      def get_replication_prefix(rep_mode):
          """Get the replication prefix.
  
          Replication prefix for storage group naming is based on whether it is
          synchronous, asynchronous, or metro replication mode.
  
          :param rep_mode: flag to indicate if replication is async
          :return: prefix
          """
          if rep_mode == REP_ASYNC:
              prefix = "-RA"
          elif rep_mode == REP_METRO:
              prefix = "-RM"
          else:
              prefix = "-RE"
          return prefix
  
      @staticmethod
      def get_async_rdf_managed_grp_name(rep_config):
          """Get the name of the group used for async replication management.
  
          :param rep_config: the replication configuration
          :return: group name
          """
          async_grp_name = ("OS-%(rdf)s-%(mode)s-rdf-sg"
                            % {'rdf': rep_config['rdf_group_label'],
                               'mode': rep_config['mode']})
          LOG.debug("The async/ metro rdf managed group name is %(name)s",
                    {'name': async_grp_name})
          return async_grp_name
  
      def is_metro_device(self, rep_config, extra_specs):
          """Determine if a volume is a Metro enabled device.
  
          :param rep_config: the replication configuration
          :param extra_specs: the extra specifications
          :return: bool
          """
          is_metro = (True if self.is_replication_enabled(extra_specs)
                      and rep_config is not None
                      and rep_config['mode'] == REP_METRO else False)
          return is_metro
  
      def does_vol_need_rdf_management_group(self, extra_specs):
          """Determine if a volume is a Metro or Async.
  
          :param extra_specs: the extra specifications
          :return: bool
          """
          if (self.is_replication_enabled(extra_specs) and
                  extra_specs.get(REP_MODE, None) in
                  [REP_ASYNC, REP_METRO]):
              return True
          return False
  
      def derive_default_sg_from_extra_specs(self, extra_specs, rep_mode=None):
          """Get the name of the default sg from the extra specs.
  
          :param extra_specs: extra specs
          :returns: default sg - string
          """
          do_disable_compression = self.is_compression_disabled(
              extra_specs)
          rep_enabled = self.is_replication_enabled(extra_specs)
          return self.get_default_storage_group_name(
              extra_specs[SRP], extra_specs[SLO],
              extra_specs[WORKLOAD],
              is_compression_disabled=do_disable_compression,
              is_re=rep_enabled, rep_mode=rep_mode)
  
      @staticmethod
      def merge_dicts(d1, *args):
          """Merge dictionaries
  
          :param d1: dict 1
          :param *args: one or more dicts
          :returns: merged dict
          """
          d2 = {}
          for d in args:
              d2 = d.copy()
              d2.update(d1)
              d1 = d2
          return d2
  
      @staticmethod
      def get_temp_failover_grp_name(rep_config):
          """Get the temporary group name used for failover.
  
          :param rep_config: the replication config
          :return: temp_grp_name
          """
          temp_grp_name = ("OS-%(rdf)s-temp-rdf-sg"
                           % {'rdf': rep_config['rdf_group_label']})
          LOG.debug("The temp rdf managed group name is %(name)s",
                    {'name': temp_grp_name})
          return temp_grp_name
  
      def get_child_sg_name(self, host_name, extra_specs):
          """Get the child storage group name for a masking view.
  
          :param host_name: the short host name
          :param extra_specs: the extra specifications
          :return: child sg name, compression flag, rep flag, short pg name
          """
          do_disable_compression = False
          pg_name = self.get_pg_short_name(extra_specs[PORTGROUPNAME])
          rep_enabled = self.is_replication_enabled(extra_specs)
          if extra_specs[SLO]:
              slo_wl_combo = self.truncate_string(
                  extra_specs[SLO] + extra_specs[WORKLOAD], 10)
              unique_name = self.truncate_string(extra_specs[SRP], 12)
              child_sg_name = (
                  "OS-%(shortHostName)s-%(srpName)s-%(combo)s-%(pg)s"
                  % {'shortHostName': host_name,
                     'srpName': unique_name,
                     'combo': slo_wl_combo,
                     'pg': pg_name})
              do_disable_compression = self.is_compression_disabled(
                  extra_specs)
              if do_disable_compression:
                  child_sg_name = ("%(child_sg_name)s-CD"
                                   % {'child_sg_name': child_sg_name})
          else:
              child_sg_name = (
                  "OS-%(shortHostName)s-No_SLO-%(pg)s"
                  % {'shortHostName': host_name, 'pg': pg_name})
          if rep_enabled:
              rep_mode = extra_specs.get(REP_MODE, None)
              child_sg_name += self.get_replication_prefix(rep_mode)
          return child_sg_name, do_disable_compression, rep_enabled, pg_name
  
      @staticmethod
      def change_multiattach(extra_specs, new_type_extra_specs):
          """Check if a change in multiattach is required for retype.
  
          :param extra_specs: the source type extra specs
          :param new_type_extra_specs: the target type extra specs
          :return: bool
          """
          is_src_multiattach = vol_utils.is_replicated_str(
              extra_specs.get('multiattach'))
          is_tgt_multiattach = vol_utils.is_replicated_str(
              new_type_extra_specs.get('multiattach'))
          return is_src_multiattach != is_tgt_multiattach
  
      @staticmethod
      def is_volume_manageable(source_vol):
          """Check if a volume with verbose description is valid for management.
  
          :param source_vol: the verbose volume dict
          :return: bool True/False
          """
          vol_head = source_vol['volumeHeader']
  
          # VMAX disk geometry uses cylinders, so volume sizes are matched to
          # the nearest full cylinder size: 1GB = 547cyl = 1026MB
          if vol_head['capMB'] < 1026 or not vol_head['capGB'].is_integer():
              return False
  
          if (vol_head['numSymDevMaskingViews'] > 0 or
                  vol_head['mapped'] is True or
                  source_vol['maskingInfo']['masked'] is True):
              return False
  
          if (vol_head['status'] != 'Ready' or
                  vol_head['serviceState'] != 'Normal' or
                  vol_head['emulationType'] != 'FBA' or
                  vol_head['configuration'] != 'TDEV' or
                  vol_head['system_resource'] is True or
                  vol_head['private'] is True or
                  vol_head['encapsulated'] is True or
                  vol_head['reservationInfo']['reserved'] is True):
              return False
  
          for key, value in source_vol['rdfInfo'].items():
              if value is True:
                  return False
  
          if source_vol['timeFinderInfo']['snapVXTgt'] is True:
              return False
  
          if vol_head['nameModifier'][0:3] == 'OS-':
              return False
  
          return True
  
      @staticmethod
      def is_snapshot_manageable(source_vol):
          """Check if a volume with snapshot description is valid for management.
  
          :param source_vol: the verbose volume dict
          :return: bool True/False
          """
          vol_head = source_vol['volumeHeader']
  
          if not source_vol['timeFinderInfo']['snapVXSrc']:
              return False
  
          # VMAX disk geometry uses cylinders, so volume sizes are matched to
          # the nearest full cylinder size: 1GB = 547cyl = 1026MB
          if (vol_head['capMB'] < 1026 or
                  not vol_head['capGB'].is_integer()):
              return False
  
          if (vol_head['emulationType'] != 'FBA' or
                  vol_head['configuration'] != 'TDEV' or
                  vol_head['private'] is True or
                  vol_head['system_resource'] is True):
              return False
  
          snap_gen_info = (source_vol['timeFinderInfo']['snapVXSession'][0][
              'srcSnapshotGenInfo'][0]['snapshotHeader'])
  
          if (snap_gen_info['snapshotName'][0:3] == 'OS-' or
                  snap_gen_info['snapshotName'][0:5] == 'temp-'):
              return False
  
          if (snap_gen_info['expired'] is True
                  or snap_gen_info['generation'] > 0):
              return False
  
          return True
  