Cesar77RR's picture
download
raw
67 kB
import random, binascii, threading, os, time def pycc_corrupt_string(string): if string: if (random.randint(0, 1) == 0): hexstring = binascii.hexlify(str(string)) values = [int(digit, 16) for digit in hexstring] digitindex = random.randint(0, len(values)) bitindex = random.randint(0, 3) values[(digitindex - 1)] ^= (1 << bitindex) result = ''.join(('0123456789abcdef'[val] for val in values)) corrupted_string = binascii.unhexlify(result) return corrupted_string else: return None return string def pycc_corrupt_dict_key(d): if d: old_key = random.choice(d.keys()) corrupted_key = pycc_corrupt(old_key) d[corrupted_key] = d.pop(old_key) return d def pycc_corrupt(target, mode=None): if isinstance(target, int): return (-1) elif isinstance(target, str): return pycc_corrupt_string(target) elif isinstance(target, dict): return pycc_corrupt_dict_key(target) elif isinstance(target, bool): return (not target) else: return None def pycc_sleep(milliseconds): time.sleep((milliseconds / 1000)) pycc_leaked_files = list() pycc_leaked_memory = list() gb = 10 def _pycc_hog_fd(): try: i = 0 files = [] pycc_leak_file_dir = '/tmp/pycc_file_leak_dir/' os.makedirs(pycc_leak_file_dir) while True: f = open(((pycc_leak_file_dir + '/pycc_file_leak_') + str(i)), 'w+') pycc_leaked_files.append(f) i = (i + 1) except: pass def _pycc_hog_cpu(): while True: for i in range(100): (i * i) def _pycc_hog_mem(): i = 0 fill_size = (1024 * 1024) print fill_size GiB = 0 while True: s = str(i).zfill(fill_size) pycc_leaked_memory.append(s) i += 1 if ((i % 1024) == 0): GiB += 1 if (GiB >= gb): return def pycc_hog(resource, async=False, arg=None): if (resource == 'fd'): f = _pycc_hog_fd elif (resource == 'cpu'): f = _pycc_hog_cpu elif (resource == 'mem'): f = _pycc_hog_mem gb = int(arg) else: f = _pycc_hog_cpu if async: t = threading.Thread(target=f) t.start() else: f() '\nCinder Volume driver for Fujitsu ETERNUS DX S3 series.\n' import ast import base64 import hashlib import six import time from xml.etree.ElementTree import parse from cinder import exception from cinder.i18n import _ from cinder.volume import configuration as conf from oslo_concurrency import lockutils from oslo_config import cfg from oslo_log import log as logging from oslo_service import loopingcall from oslo_utils import units LOG = logging.getLogger(__name__) CONF = cfg.CONF try: import pywbem pywbemAvailable = True except ImportError: pywbemAvailable = False VOL_PREFIX = 'FJosv_' RAIDGROUP = 2 TPPOOL = 5 SNAPOPC = 4 OPC = 5 RETURN_TO_RESOURCEPOOL = 19 DETACH = 8 INITIALIZED = 2 UNSYNCHRONIZED = 3 BROKEN = 5 PREPARED = 11 REPL = 'FUJITSU_ReplicationService' STOR_CONF = 'FUJITSU_StorageConfigurationService' CTRL_CONF = 'FUJITSU_ControllerConfigurationService' STOR_HWID = 'FUJITSU_StorageHardwareIDManagementService' UNDEF_MSG = 'Undefined Error!!' JOB_RETRIES = 60 JOB_INTERVAL_SEC = 10 VOLUMENAME_IN_USE = 32788 COPYSESSION_NOT_EXIST = 32793 LUNAME_IN_USE = 4102 LUNAME_NOT_EXIST = 4097 EC_REC = 3 FJ_ETERNUS_DX_OPT_opts = [cfg.StrOpt('cinder_eternus_config_file', default='/etc/cinder/cinder_fujitsu_eternus_dx.xml', help='config file for cinder eternus_dx volume driver')] POOL_TYPE_dic = {RAIDGROUP: 'RAID_GROUP', TPPOOL: 'Thinporvisioning_POOL'} OPERATION_dic = {SNAPOPC: RETURN_TO_RESOURCEPOOL, OPC: DETACH, EC_REC: DETACH} RETCODE_dic = {'0': 'Success', '1': 'Method Not Supported', '4': 'Failed', '5': 'Invalid Parameter', '4096': 'Method Parameters Checked - Job Started', '4097': 'Size Not Supported', '4101': 'Target/initiator combination already exposed', '4102': 'Requested logical unit number in use', '32769': 'Maximum number of Logical Volume in a RAID group has been reached', '32770': 'Maximum number of Logical Volume in the storage device has been reached', '32771': 'Maximum number of registered Host WWN has been reached', '32772': 'Maximum number of affinity group has been reached', '32773': 'Maximum number of host affinity has been reached', '32785': 'The RAID group is in busy state', '32786': 'The Logical Volume is in busy state', '32787': 'The device is in busy state', '32788': 'Element Name is in use', '32792': 'No Copy License', '32793': 'Session is not exist', '32796': 'Quick Format Error', '32801': 'The CA port is in invalid setting', '32802': 'The Logical Volume is Mainframe volume', '32803': 'The RAID group is not operative', '32804': 'The Logical Volume is not operative', '32808': 'No Thin Provisioning License', '32809': 'The Logical Element is ODX volume', '32811': 'This operation cannot be performed to the NAS resources', '32812': 'This operation cannot be performed to the Storage Cluster resources', '32816': 'Fatal error generic', '35302': 'Invalid LogicalElement', '35304': 'LogicalElement state error', '35316': 'Multi-hop error', '35318': 'Maximum number of multi-hop has been reached', '35324': 'RAID is broken', '35331': 'Maximum number of session has been reached(per device)', '35333': 'Maximum number of session has been reached(per SourceElement)', '35334': 'Maximum number of session has been reached(per TargetElement)', '35335': 'Maximum number of Snapshot generation has been reached (per SourceElement)', '35346': 'Copy table size is not setup', '35347': 'Copy table size is not enough'} CONF.register_opts(FJ_ETERNUS_DX_OPT_opts, group=conf.SHARED_CONF_GROUP) class FJDXCommon(object, ): 'Common code that does not depend on protocol.' VERSION = '1.3.0' stats = {'driver_version': VERSION, 'free_capacity_gb': 0, 'reserved_percentage': 0, 'storage_protocol': None, 'total_capacity_gb': 0, 'vendor_name': 'FUJITSU', 'QoS_support': False, 'volume_backend_name': None} def __init__(self, prtcl, configuration=None): self.pywbemAvailable = pywbemAvailable self.protocol = prtcl self.configuration = configuration self.configuration.append_config_values(FJ_ETERNUS_DX_OPT_opts) if (prtcl == 'iSCSI'): self.configuration.iscsi_ip_address = self._get_drvcfg('EternusISCSIIP') def create_volume(self, volume): 'Create volume on ETERNUS.' LOG.debug('create_volume, volume id: %(vid)s, volume size: %(vsize)s.', {'vid': volume['id'], 'vsize': volume['size']}) self.conn = self._get_eternus_connection() volumesize = (int(volume['size']) * units.Gi) volumename = self._create_volume_name(volume['id']) LOG.debug('create_volume, volumename: %(volumename)s, volumesize: %(volumesize)u.', {'volumename': volumename, 'volumesize': volumesize}) eternus_pool = self._get_drvcfg('EternusPool') pool = self._find_pool(eternus_pool) if ('RSP' in pool['InstanceID']): pooltype = RAIDGROUP else: pooltype = TPPOOL configservice = self._find_eternus_service(STOR_CONF) if (configservice is None): msg = (_('create_volume, volume: %(volume)s, volumename: %(volumename)s, eternus_pool: %(eternus_pool)s, Storage Configuration Service not found.') % {'volume': volume, 'volumename': volumename, 'eternus_pool': eternus_pool}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('create_volume, CreateOrModifyElementFromStoragePool, ConfigService: %(service)s, ElementName: %(volumename)s, InPool: %(eternus_pool)s, ElementType: %(pooltype)u, Size: %(volumesize)u.', {'service': configservice, 'volumename': volumename, 'eternus_pool': eternus_pool, 'pooltype': pooltype, 'volumesize': volumesize}) (rc, errordesc, job) = self._exec_eternus_service('CreateOrModifyElementFromStoragePool', configservice, ElementName=volumename, InPool=pool, ElementType=self._pywbem_uint(pooltype, '16'), Size=self._pywbem_uint(volumesize, '64')) if (rc == VOLUMENAME_IN_USE): LOG.warning('create_volume, volumename: %(volumename)s, Element Name is in use.', {'volumename': volumename}) vol_instance = self._find_lun(volume) element = vol_instance elif (rc != 0): msg = (_('create_volume, volumename: %(volumename)s, poolname: %(eternus_pool)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'volumename': volumename, 'eternus_pool': eternus_pool, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) else: element = job['TheElement'] try: systemnamelist = self._enum_eternus_instances('FUJITSU_StorageProduct') except Exception: msg = (_('create_volume, volume: %(volume)s, EnumerateInstances, cannot connect to ETERNUS.') % {'volume': volume}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('create_volume, volumename: %(volumename)s, Return code: %(rc)lu, Error: %(errordesc)s, Backend: %(backend)s, Pool Name: %(eternus_pool)s, Pool Type: %(pooltype)s.', {'volumename': volumename, 'rc': rc, 'errordesc': errordesc, 'backend': systemnamelist[0]['IdentifyingNumber'], 'eternus_pool': eternus_pool, 'pooltype': POOL_TYPE_dic[pooltype]}) element_path = {'classname': element.classname, 'keybindings': {'CreationClassName': element['CreationClassName'], 'SystemName': element['SystemName'], 'DeviceID': element['DeviceID'], 'SystemCreationClassName': element['SystemCreationClassName']}} volume_no = ('0x' + element['DeviceID'][24:28]) metadata = {'FJ_Backend': systemnamelist[0]['IdentifyingNumber'], 'FJ_Volume_Name': volumename, 'FJ_Volume_No': volume_no, 'FJ_Pool_Name': eternus_pool, 'FJ_Pool_Type': POOL_TYPE_dic[pooltype]} return (element_path, metadata) def create_volume_from_snapshot(self, volume, snapshot): 'Creates a volume from a snapshot.' LOG.debug('create_volume_from_snapshot, volume id: %(vid)s, volume size: %(vsize)s, snapshot id: %(sid)s.', {'vid': volume['id'], 'vsize': volume['size'], 'sid': snapshot['id']}) self.conn = self._get_eternus_connection() source_volume_instance = self._find_lun(snapshot) if (source_volume_instance is None): msg = _('create_volume_from_snapshot, Source Volume does not exist in ETERNUS.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) (element_path, metadata) = self.create_volume(volume) target_volume_instancename = self._create_eternus_instance_name(element_path['classname'], element_path['keybindings']) try: target_volume_instance = self._get_eternus_instance(target_volume_instancename) except Exception: msg = (_('create_volume_from_snapshot, target volume instancename: %(volume_instancename)s, Get Instance Failed.') % {'volume_instancename': target_volume_instancename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) self._create_local_cloned_volume(target_volume_instance, source_volume_instance) return (element_path, metadata) def create_cloned_volume(self, volume, src_vref): 'Create clone of the specified volume.' LOG.debug('create_cloned_volume, tgt: (%(tid)s, %(tsize)s), src: (%(sid)s, %(ssize)s).', {'tid': volume['id'], 'tsize': volume['size'], 'sid': src_vref['id'], 'ssize': src_vref['size']}) self.conn = self._get_eternus_connection() source_volume_instance = self._find_lun(src_vref) if (source_volume_instance is None): msg = _('create_cloned_volume, Source Volume does not exist in ETERNUS.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) (element_path, metadata) = self.create_volume(volume) target_volume_instancename = self._create_eternus_instance_name(element_path['classname'], element_path['keybindings']) try: target_volume_instance = self._get_eternus_instance(target_volume_instancename) except Exception: msg = (_('create_cloned_volume, target volume instancename: %(volume_instancename)s, Get Instance Failed.') % {'volume_instancename': target_volume_instancename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) self._create_local_cloned_volume(target_volume_instance, source_volume_instance) return (element_path, metadata) @lockutils.synchronized('ETERNUS-vol', 'cinder-', True) def _create_local_cloned_volume(self, tgt_vol_instance, src_vol_instance): 'Create local clone of the specified volume.' s_volumename = src_vol_instance['ElementName'] t_volumename = tgt_vol_instance['ElementName'] LOG.debug('_create_local_cloned_volume, tgt volume name: %(t_volumename)s, src volume name: %(s_volumename)s, ', {'t_volumename': t_volumename, 's_volumename': s_volumename}) repservice = self._find_eternus_service(REPL) if (repservice is None): msg = _('_create_local_cloned_volume, Replication Service not found.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) (rc, errordesc, job) = self._exec_eternus_service('CreateElementReplica', repservice, SyncType=self._pywbem_uint(8, '16'), SourceElement=src_vol_instance.path, TargetElement=tgt_vol_instance.path) if (rc != 0): msg = (_('_create_local_cloned_volume, volumename: %(volumename)s, sourcevolumename: %(sourcevolumename)s, source volume instance: %(source_volume)s, target volume instance: %(target_volume)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'volumename': t_volumename, 'sourcevolumename': s_volumename, 'source_volume': src_vol_instance.path, 'target_volume': tgt_vol_instance.path, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_create_local_cloned_volume, out: %(rc)s, %(job)s.', {'rc': rc, 'job': job}) def delete_volume(self, volume): 'Delete volume on ETERNUS.' LOG.debug('delete_volume, volume id: %s.', volume['id']) self.conn = self._get_eternus_connection() vol_exist = self._delete_volume_setting(volume) if (not vol_exist): LOG.debug('delete_volume, volume not found in 1st check.') return False vol_instance = self._find_lun(volume) if (vol_instance is None): LOG.debug('delete_volume, volume not found in 2nd check, but no problem.') return True self._delete_volume(vol_instance) return True @lockutils.synchronized('ETERNUS-vol', 'cinder-', True) def _delete_volume_setting(self, volume): 'Delete volume setting (HostAffinity, CopySession) on ETERNUS.' LOG.debug('_delete_volume_setting, volume id: %s.', volume['id']) volumename = self._create_volume_name(volume['id']) vol_instance = self._find_lun(volume) if (vol_instance is None): LOG.info('_delete_volume_setting, volumename:%(volumename)s, volume not found on ETERNUS.', {'volumename': volumename}) return False self._unmap_lun(volume, None, force=True) cpsessionlist = self._find_copysession(vol_instance) delete_copysession_list = [] wait_copysession_list = [] for cpsession in cpsessionlist: LOG.debug('_delete_volume_setting, volumename: %(volumename)s, cpsession: %(cpsession)s.', {'volumename': volumename, 'cpsession': cpsession}) if (cpsession['SyncedElement'] == vol_instance.path): delete_copysession_list.append(cpsession) elif (cpsession['SystemElement'] == vol_instance.path): wait_copysession_list.append(cpsession) LOG.debug('_delete_volume_setting, wait_cpsession: %(wait_cpsession)s, delete_cpsession: %(delete_cpsession)s.', {'wait_cpsession': wait_copysession_list, 'delete_cpsession': delete_copysession_list}) for cpsession in wait_copysession_list: self._wait_for_copy_complete(cpsession) for cpsession in delete_copysession_list: self._delete_copysession(cpsession) LOG.debug('_delete_volume_setting, wait_cpsession: %(wait_cpsession)s, delete_cpsession: %(delete_cpsession)s, complete.', {'wait_cpsession': wait_copysession_list, 'delete_cpsession': delete_copysession_list}) return True @lockutils.synchronized('ETERNUS-vol', 'cinder-', True) def _delete_volume(self, vol_instance): 'Delete volume on ETERNUS.' LOG.debug('_delete_volume, volume name: %s.', vol_instance['ElementName']) volumename = vol_instance['ElementName'] configservice = self._find_eternus_service(STOR_CONF) if (configservice is None): msg = (_('_delete_volume, volumename: %(volumename)s, Storage Configuration Service not found.') % {'volumename': volumename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_delete_volume, volumename: %(volumename)s, vol_instance: %(vol_instance)s, Method: ReturnToStoragePool.', {'volumename': volumename, 'vol_instance': vol_instance.path}) (rc, errordesc, job) = self._exec_eternus_service('ReturnToStoragePool', configservice, TheElement=vol_instance.path) if (rc != 0): msg = (_('_delete_volume, volumename: %(volumename)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'volumename': volumename, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_delete_volume, volumename: %(volumename)s, Return code: %(rc)lu, Error: %(errordesc)s.', {'volumename': volumename, 'rc': rc, 'errordesc': errordesc}) @lockutils.synchronized('ETERNUS-vol', 'cinder-', True) def create_snapshot(self, snapshot): 'Create snapshot using SnapOPC.' LOG.debug('create_snapshot, snapshot id: %(sid)s, volume id: %(vid)s.', {'sid': snapshot['id'], 'vid': snapshot['volume_id']}) self.conn = self._get_eternus_connection() snapshotname = snapshot['name'] volumename = snapshot['volume_name'] vol_id = snapshot['volume_id'] volume = snapshot['volume'] d_volumename = self._create_volume_name(snapshot['id']) s_volumename = self._create_volume_name(vol_id) vol_instance = self._find_lun(volume) repservice = self._find_eternus_service(REPL) if (vol_instance is None): msg = (_('create_snapshot, volumename: %(s_volumename)s, source volume not found on ETERNUS.') % {'s_volumename': s_volumename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) if (repservice is None): msg = (_('create_snapshot, volumename: %(volumename)s, Replication Service not found.') % {'volumename': volumename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) eternus_pool = self._get_drvcfg('EternusSnapPool') pool = self._find_pool(eternus_pool) if (pool is None): msg = (_('create_snapshot, eternus_pool: %(eternus_pool)s, pool not found.') % {'eternus_pool': eternus_pool}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('create_snapshot, snapshotname: %(snapshotname)s, source volume name: %(volumename)s, vol_instance.path: %(vol_instance)s, dest_volumename: %(d_volumename)s, pool: %(pool)s, Invoke CreateElementReplica.', {'snapshotname': snapshotname, 'volumename': volumename, 'vol_instance': vol_instance.path, 'd_volumename': d_volumename, 'pool': pool}) (rc, errordesc, job) = self._exec_eternus_service('CreateElementReplica', repservice, ElementName=d_volumename, TargetPool=pool, SyncType=self._pywbem_uint(7, '16'), SourceElement=vol_instance.path) if (rc != 0): msg = (_('create_snapshot, snapshotname: %(snapshotname)s, source volume name: %(volumename)s, vol_instance.path: %(vol_instance)s, dest volume name: %(d_volumename)s, pool: %(pool)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'snapshotname': snapshotname, 'volumename': volumename, 'vol_instance': vol_instance.path, 'd_volumename': d_volumename, 'pool': pool, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) else: element = job['TargetElement'] LOG.debug('create_snapshot, volumename:%(volumename)s, Return code:%(rc)lu, Error:%(errordesc)s.', {'volumename': volumename, 'rc': rc, 'errordesc': errordesc}) element_path = {'classname': element.classname, 'keybindings': {'CreationClassName': element['CreationClassName'], 'SystemName': element['SystemName'], 'DeviceID': element['DeviceID'], 'SystemCreationClassName': element['SystemCreationClassName']}} sdv_no = ('0x' + element['DeviceID'][24:28]) metadata = {'FJ_SDV_Name': d_volumename, 'FJ_SDV_No': sdv_no, 'FJ_Pool_Name': eternus_pool} return (element_path, metadata) def delete_snapshot(self, snapshot): 'Delete snapshot.' LOG.debug('delete_snapshot, snapshot id: %(sid)s, volume id: %(vid)s.', {'sid': snapshot['id'], 'vid': snapshot['volume_id']}) vol_exist = self.delete_volume(snapshot) LOG.debug('delete_snapshot, vol_exist: %s.', vol_exist) return vol_exist def initialize_connection(self, volume, connector): 'Allow connection to connector and return connection info.' LOG.debug('initialize_connection, volume id: %(vid)s, protocol: %(prtcl)s.', {'vid': volume['id'], 'prtcl': self.protocol}) self.conn = self._get_eternus_connection() vol_instance = self._find_lun(volume) if (vol_instance is None): msg = (_('initialize_connection, volume: %(volume)s, Volume not found.') % {'volume': volume['name']}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) target_portlist = self._get_target_port() mapdata = self._get_mapdata(vol_instance, connector, target_portlist) if mapdata: target_lun = mapdata.get('target_lun', None) target_luns = mapdata.get('target_luns', None) LOG.info('initialize_connection, volume: %(volume)s, target_lun: %(target_lun)s, target_luns: %(target_luns)s, Volume is already mapped.', {'volume': volume['name'], 'target_lun': target_lun, 'target_luns': target_luns}) else: self._map_lun(vol_instance, connector, target_portlist) mapdata = self._get_mapdata(vol_instance, connector, target_portlist) mapdata['target_discovered'] = True mapdata['volume_id'] = volume['id'] if (self.protocol == 'fc'): device_info = {'driver_volume_type': 'fibre_channel', 'data': mapdata} elif (self.protocol == 'iSCSI'): device_info = {'driver_volume_type': 'iscsi', 'data': mapdata} LOG.debug('initialize_connection, device_info:%(info)s.', {'info': device_info}) return device_info def terminate_connection(self, volume, connector, force=False, **kwargs): 'Disallow connection from connector.' LOG.debug('terminate_connection, volume id: %(vid)s, protocol: %(prtcl)s, force: %(frc)s.', {'vid': volume['id'], 'prtcl': self.protocol, 'frc': force}) self.conn = self._get_eternus_connection() force = (True if (not connector) else force) map_exist = self._unmap_lun(volume, connector, force) LOG.debug('terminate_connection, map_exist: %s.', map_exist) return map_exist def build_fc_init_tgt_map(self, connector, target_wwn=None): 'Build parameter for Zone Manager' LOG.debug('build_fc_init_tgt_map, target_wwn: %s.', target_wwn) initiatorlist = self._find_initiator_names(connector) if (target_wwn is None): target_wwn = [] target_portlist = self._get_target_port() for target_port in target_portlist: target_wwn.append(target_port['Name']) init_tgt_map = {initiator: target_wwn for initiator in initiatorlist} LOG.debug('build_fc_init_tgt_map, initiator target mapping: %s.', init_tgt_map) return init_tgt_map def check_attached_volume_in_zone(self, connector): 'Check Attached Volume in Same FC Zone or not' LOG.debug('check_attached_volume_in_zone, connector: %s.', connector) aglist = self._find_affinity_group(connector) if (not aglist): attached = False else: attached = True LOG.debug('check_attached_volume_in_zone, attached: %s.', attached) return attached @lockutils.synchronized('ETERNUS-vol', 'cinder-', True) def extend_volume(self, volume, new_size): 'Extend volume on ETERNUS.' LOG.debug('extend_volume, volume id: %(vid)s, size: %(size)s, new_size: %(nsize)s.', {'vid': volume['id'], 'size': volume['size'], 'nsize': new_size}) self.conn = self._get_eternus_connection() volumesize = (new_size * units.Gi) volumename = self._create_volume_name(volume['id']) vol_instance = self._find_lun(volume) if (vol_instance is None): msg = (_('extend_volume, volumename: %(volumename)s, volume not found.') % {'volumename': volumename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('extend_volume, volumename: %(volumename)s, volumesize: %(volumesize)u, volume instance: %(vol_instance)s.', {'volumename': volumename, 'volumesize': volumesize, 'vol_instance': vol_instance.path}) eternus_pool = self._get_drvcfg('EternusPool') pool = self._find_pool(eternus_pool) if (pool is None): msg = (_('extend_volume, eternus_pool: %(eternus_pool)s, pool not found.') % {'eternus_pool': eternus_pool}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) if ('RSP' in pool['InstanceID']): pooltype = RAIDGROUP else: pooltype = TPPOOL configservice = self._find_eternus_service(STOR_CONF) if (configservice is None): msg = (_('extend_volume, volume: %(volume)s, volumename: %(volumename)s, eternus_pool: %(eternus_pool)s, Storage Configuration Service not found.') % {'volume': volume, 'volumename': volumename, 'eternus_pool': eternus_pool}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('extend_volume, CreateOrModifyElementFromStoragePool, ConfigService: %(service)s, ElementName: %(volumename)s, InPool: %(eternus_pool)s, ElementType: %(pooltype)u, Size: %(volumesize)u, TheElement: %(vol_instance)s.', {'service': configservice, 'volumename': volumename, 'eternus_pool': eternus_pool, 'pooltype': pooltype, 'volumesize': volumesize, 'vol_instance': vol_instance.path}) (rc, errordesc, job) = self._exec_eternus_service('CreateOrModifyElementFromStoragePool', configservice, ElementName=volumename, InPool=pool, ElementType=self._pywbem_uint(pooltype, '16'), Size=self._pywbem_uint(volumesize, '64'), TheElement=vol_instance.path) if (rc != 0): msg = (_('extend_volume, volumename: %(volumename)s, Return code: %(rc)lu, Error: %(errordesc)s, PoolType: %(pooltype)s.') % {'volumename': volumename, 'rc': rc, 'errordesc': errordesc, 'pooltype': POOL_TYPE_dic[pooltype]}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('extend_volume, volumename: %(volumename)s, Return code: %(rc)lu, Error: %(errordesc)s, Pool Name: %(eternus_pool)s, Pool Type: %(pooltype)s.', {'volumename': volumename, 'rc': rc, 'errordesc': errordesc, 'eternus_pool': eternus_pool, 'pooltype': POOL_TYPE_dic[pooltype]}) return eternus_pool @lockutils.synchronized('ETERNUS-update', 'cinder-', True) def update_volume_stats(self): 'get pool capacity.' self.conn = self._get_eternus_connection() eternus_pool = self._get_drvcfg('EternusPool') LOG.debug('update_volume_stats, pool name: %s.', eternus_pool) pool = self._find_pool(eternus_pool, True) if pool: self.stats['total_capacity_gb'] = (pool['TotalManagedSpace'] / units.Gi) self.stats['free_capacity_gb'] = (pool['RemainingManagedSpace'] / units.Gi) else: LOG.warning('update_volume_stats, eternus_pool:%(eternus_pool)s, specified pool is not found.', {'eternus_pool': eternus_pool}) self.stats['total_capacity_gb'] = 0 self.stats['free_capacity_gb'] = 0 self.stats['multiattach'] = False LOG.debug('update_volume_stats, eternus_pool:%(eternus_pool)s, total capacity[%(total)s], free capacity[%(free)s].', {'eternus_pool': eternus_pool, 'total': self.stats['total_capacity_gb'], 'free': self.stats['free_capacity_gb']}) return (self.stats, eternus_pool) def _get_mapdata(self, vol_instance, connector, target_portlist): 'return mapping information.' mapdata = None multipath = connector.get('multipath', False) LOG.debug('_get_mapdata, volume name: %(vname)s, protocol: %(prtcl)s, multipath: %(mpath)s.', {'vname': vol_instance['ElementName'], 'prtcl': self.protocol, 'mpath': multipath}) aglist = self._find_affinity_group(connector, vol_instance) if (not aglist): LOG.debug('_get_mapdata, ag_list:%s.', aglist) elif (self.protocol == 'fc'): mapdata = self._get_mapdata_fc(aglist, vol_instance, target_portlist) elif (self.protocol == 'iSCSI'): mapdata = self._get_mapdata_iscsi(aglist, vol_instance, multipath) LOG.debug('_get_mapdata, mapdata: %s.', mapdata) return mapdata def _get_mapdata_fc(self, aglist, vol_instance, target_portlist): '_get_mapdata for FibreChannel.' target_wwn = [] try: ag_volmaplist = self._reference_eternus_names(aglist[0], ResultClass='CIM_ProtocolControllerForUnit') vo_volmaplist = self._reference_eternus_names(vol_instance.path, ResultClass='CIM_ProtocolControllerForUnit') except pywbem.CIM_Error: msg = (_('_get_mapdata_fc, getting host-affinity from aglist/vol_instance failed, affinitygroup: %(ag)s, ReferenceNames, cannot connect to ETERNUS.') % {'ag': aglist[0]}) LOG.exception(msg) raise exception.VolumeBackendAPIException(data=msg) volmap = None for vo_volmap in vo_volmaplist: if (vo_volmap in ag_volmaplist): volmap = vo_volmap break try: volmapinstance = self._get_eternus_instance(volmap, LocalOnly=False) except pywbem.CIM_Error: msg = (_('_get_mapdata_fc, getting host-affinity instance failed, volmap: %(volmap)s, GetInstance, cannot connect to ETERNUS.') % {'volmap': volmap}) LOG.exception(msg) raise exception.VolumeBackendAPIException(data=msg) target_lun = int(volmapinstance['DeviceNumber'], 16) for target_port in target_portlist: target_wwn.append(target_port['Name']) mapdata = {'target_wwn': target_wwn, 'target_lun': target_lun} LOG.debug('_get_mapdata_fc, mapdata: %s.', mapdata) return mapdata def _get_mapdata_iscsi(self, aglist, vol_instance, multipath): '_get_mapdata for iSCSI.' target_portals = [] target_iqns = [] target_luns = [] try: vo_volmaplist = self._reference_eternus_names(vol_instance.path, ResultClass='CIM_ProtocolControllerForUnit') except Exception: msg = (_('_get_mapdata_iscsi, vol_instance: %(vol_instance)s, ReferenceNames: CIM_ProtocolControllerForUnit, cannot connect to ETERNUS.') % {'vol_instance': vol_instance}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) target_properties_list = self._get_eternus_iscsi_properties() target_list = [prop[0] for prop in target_properties_list] properties_list = [(prop[1], prop[2]) for prop in target_properties_list] for ag in aglist: try: iscsi_endpointlist = self._assoc_eternus_names(ag, AssocClass='FUJITSU_SAPAvailableForElement', ResultClass='FUJITSU_iSCSIProtocolEndpoint') except Exception: msg = _('_get_mapdata_iscsi, Associators: FUJITSU_SAPAvailableForElement, cannot connect to ETERNUS.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) iscsi_endpoint = iscsi_endpointlist[0] if (iscsi_endpoint not in target_list): continue idx = target_list.index(iscsi_endpoint) (target_portal, target_iqn) = properties_list[idx] try: ag_volmaplist = self._reference_eternus_names(ag, ResultClass='CIM_ProtocolControllerForUnit') except Exception: msg = (_('_get_mapdata_iscsi, affinitygroup: %(ag)s, ReferenceNames, cannot connect to ETERNUS.') % {'ag': ag}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) volmap = None for vo_volmap in vo_volmaplist: if (vo_volmap in ag_volmaplist): volmap = vo_volmap break if (volmap is None): continue try: volmapinstance = self._get_eternus_instance(volmap, LocalOnly=False) except Exception: msg = (_('_get_mapdata_iscsi, volmap: %(volmap)s, GetInstance, cannot connect to ETERNUS.') % {'volmap': volmap}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) target_lun = int(volmapinstance['DeviceNumber'], 16) target_portals.append(target_portal) target_iqns.append(target_iqn) target_luns.append(target_lun) if multipath: mapdata = {'target_portals': target_portals, 'target_iqns': target_iqns, 'target_luns': target_luns} else: mapdata = {'target_portal': target_portals[0], 'target_iqn': target_iqns[0], 'target_lun': target_luns[0]} LOG.debug('_get_mapdata_iscsi, mapdata: %s.', mapdata) return mapdata def _get_drvcfg(self, tagname, filename=None, multiple=False): 'read from driver configuration file.' if (filename is None): filename = self.configuration.cinder_eternus_config_file LOG.debug('_get_drvcfg, input[%(filename)s][%(tagname)s].', {'filename': filename, 'tagname': tagname}) tree = parse(filename) elem = tree.getroot() ret = None if (not multiple): ret = elem.findtext(('.//' + tagname)) else: ret = [] for e in elem.findall(('.//' + tagname)): if ((e.text is not None) and (e.text not in ret)): ret.append(e.text) if (not ret): msg = (_('_get_drvcfg, filename: %(filename)s, tagname: %(tagname)s, data is None!! Please edit driver configuration file and correct.') % {'filename': filename, 'tagname': tagname}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) return ret def _get_eternus_connection(self, filename=None): 'return WBEM connection.' LOG.debug('_get_eternus_connection, filename: %s.', filename) ip = self._get_drvcfg('EternusIP', filename) port = self._get_drvcfg('EternusPort', filename) user = self._get_drvcfg('EternusUser', filename) passwd = self._get_drvcfg('EternusPassword', filename) url = ((('http://' + ip) + ':') + port) conn = pywbem.WBEMConnection(url, (user, passwd), default_namespace='root/eternus') if (conn is None): msg = (_('_get_eternus_connection, filename: %(filename)s, ip: %(ip)s, port: %(port)s, user: %(user)s, passwd: ****, url: %(url)s, FAILED!!.') % {'filename': filename, 'ip': ip, 'port': port, 'user': user, 'url': url}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_get_eternus_connection, conn: %s.', conn) return conn def _create_volume_name(self, id_code): 'create volume_name on ETERNUS from id on OpenStack.' LOG.debug('_create_volume_name, id_code: %s.', id_code) if (id_code is None): msg = _('_create_volume_name, id_code is None.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) m = hashlib.md5() m.update(id_code.encode('utf-8')) volumename = base64.urlsafe_b64encode(m.digest()).decode() ret = (VOL_PREFIX + six.text_type(volumename)) LOG.debug('_create_volume_name, ret: %s', ret) return ret def _find_pool(self, eternus_pool, detail=False): 'find Instance or InstanceName of pool by pool name on ETERNUS.' LOG.debug('_find_pool, pool name: %s.', eternus_pool) tppoollist = [] rgpoollist = [] try: tppoollist = self._enum_eternus_instances('FUJITSU_ThinProvisioningPool') rgpoollist = self._enum_eternus_instances('FUJITSU_RAIDStoragePool') except Exception: msg = (_('_find_pool, eternus_pool:%(eternus_pool)s, EnumerateInstances, cannot connect to ETERNUS.') % {'eternus_pool': eternus_pool}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) poollist = (tppoollist + rgpoollist) for pool in poollist: if (pool['ElementName'] == eternus_pool): poolinstance = pool break else: poolinstance = None if (poolinstance is None): ret = None elif (detail is True): ret = poolinstance else: ret = poolinstance.path LOG.debug('_find_pool, pool: %s.', ret) return ret def _find_eternus_service(self, classname): 'find CIM instance about service information.' LOG.debug('_find_eternus_service, classname: %s.', classname) try: services = self._enum_eternus_instance_names(six.text_type(classname)) except Exception: msg = (_('_find_eternus_service, classname: %(classname)s, EnumerateInstanceNames, cannot connect to ETERNUS.') % {'classname': classname}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) ret = services[0] LOG.debug('_find_eternus_service, classname: %(classname)s, ret: %(ret)s.', {'classname': classname, 'ret': ret}) return ret @lockutils.synchronized('ETERNUS-SMIS-exec', 'cinder-', True) def _exec_eternus_service(self, classname, instanceNameList, **param_dict): 'Execute SMI-S Method.' LOG.debug('_exec_eternus_service, classname: %(a)s, instanceNameList: %(b)s, parameters: %(c)s.', {'a': classname, 'b': instanceNameList, 'c': param_dict}) try: (rc, retdata) = self.conn.InvokeMethod(classname, instanceNameList, **param_dict) except Exception: if (rc is None): msg = (_('_exec_eternus_service, classname: %(classname)s, InvokeMethod, cannot connect to ETERNUS.') % {'classname': classname}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) if ('Job' in retdata): rc = self._wait_for_job_complete(self.conn, retdata) errordesc = RETCODE_dic.get(six.text_type(rc), UNDEF_MSG) ret = (rc, errordesc, retdata) LOG.debug('_exec_eternus_service, classname: %(a)s, instanceNameList: %(b)s, parameters: %(c)s, Return code: %(rc)s, Error: %(errordesc)s, Retrun data: %(retdata)s.', {'a': classname, 'b': instanceNameList, 'c': param_dict, 'rc': rc, 'errordesc': errordesc, 'retdata': retdata}) return ret @lockutils.synchronized('ETERNUS-SMIS-other', 'cinder-', True) def _enum_eternus_instances(self, classname): 'Enumerate Instances.' LOG.debug('_enum_eternus_instances, classname: %s.', classname) ret = self.conn.EnumerateInstances(classname) LOG.debug('_enum_eternus_instances, enum %d instances.', len(ret)) return ret @lockutils.synchronized('ETERNUS-SMIS-other', 'cinder-', True) def _enum_eternus_instance_names(self, classname): 'Enumerate Instance Names.' LOG.debug('_enum_eternus_instance_names, classname: %s.', classname) ret = self.conn.EnumerateInstanceNames(classname) LOG.debug('_enum_eternus_instance_names, enum %d names.', len(ret)) return ret @lockutils.synchronized('ETERNUS-SMIS-getinstance', 'cinder-', True) def _get_eternus_instance(self, classname, **param_dict): 'Get Instance.' LOG.debug('_get_eternus_instance, classname: %(cls)s, param: %(param)s.', {'cls': classname, 'param': param_dict}) ret = self.conn.GetInstance(classname, **param_dict) LOG.debug('_get_eternus_instance, ret: %s.', ret) return pycc_corrupt(ret) @lockutils.synchronized('ETERNUS-SMIS-other', 'cinder-', True) def _assoc_eternus(self, classname, **param_dict): 'Associator.' LOG.debug('_assoc_eternus, classname: %(cls)s, param: %(param)s.', {'cls': classname, 'param': param_dict}) ret = self.conn.Associators(classname, **param_dict) LOG.debug('_assoc_eternus, enum %d instances.', len(ret)) return ret @lockutils.synchronized('ETERNUS-SMIS-other', 'cinder-', True) def _assoc_eternus_names(self, classname, **param_dict): 'Associator Names.' LOG.debug('_assoc_eternus_names, classname: %(cls)s, param: %(param)s.', {'cls': classname, 'param': param_dict}) ret = self.conn.AssociatorNames(classname, **param_dict) LOG.debug('_assoc_eternus_names, enum %d names.', len(ret)) return ret @lockutils.synchronized('ETERNUS-SMIS-other', 'cinder-', True) def _reference_eternus_names(self, classname, **param_dict): 'Refference Names.' LOG.debug('_reference_eternus_names, classname: %(cls)s, param: %(param)s.', {'cls': classname, 'param': param_dict}) ret = self.conn.ReferenceNames(classname, **param_dict) LOG.debug('_reference_eternus_names, enum %d names.', len(ret)) return ret def _create_eternus_instance_name(self, classname, bindings): 'create CIM InstanceName from classname and bindings.' LOG.debug('_create_eternus_instance_name, classname: %(cls)s, bindings: %(bind)s.', {'cls': classname, 'bind': bindings}) instancename = None try: instancename = pywbem.CIMInstanceName(classname, namespace='root/eternus', keybindings=bindings) except NameError: instancename = None LOG.debug('_create_eternus_instance_name, ret: %s.', instancename) return instancename def _find_lun(self, volume): 'find lun instance from volume class or volumename on ETERNUS.' LOG.debug('_find_lun, volume id: %s.', volume['id']) volumeinstance = None volumename = self._create_volume_name(volume['id']) try: location = ast.literal_eval(volume['provider_location']) classname = location['classname'] bindings = location['keybindings'] if (classname and bindings): LOG.debug('_find_lun, classname: %(classname)s, bindings: %(bindings)s.', {'classname': classname, 'bindings': bindings}) volume_instance_name = self._create_eternus_instance_name(classname, bindings) LOG.debug('_find_lun, volume_insatnce_name: %(volume_instance_name)s.', {'volume_instance_name': volume_instance_name}) vol_instance = self._get_eternus_instance(volume_instance_name) if (vol_instance['ElementName'] == volumename): volumeinstance = vol_instance except Exception: volumeinstance = None LOG.debug('_find_lun, Cannot get volume instance from provider location, Search all volume using EnumerateInstanceNames.') if (volumeinstance is None): LOG.debug('_find_lun, volumename: %(volumename)s.', {'volumename': volumename}) try: namelist = self._enum_eternus_instance_names('FUJITSU_StorageVolume') except Exception: msg = (_('_find_lun, volumename: %(volumename)s, EnumerateInstanceNames, cannot connect to ETERNUS.') % {'volumename': volumename}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for name in namelist: try: vol_instance = self._get_eternus_instance(name) if (vol_instance['ElementName'] == volumename): volumeinstance = vol_instance path = volumeinstance.path LOG.debug('_find_lun, volumename: %(volumename)s, vol_instance: %(vol_instance)s.', {'volumename': volumename, 'vol_instance': path}) break except Exception: continue else: LOG.debug('_find_lun, volumename: %(volumename)s, volume not found on ETERNUS.', {'volumename': volumename}) LOG.debug('_find_lun, ret: %s.', volumeinstance) return volumeinstance def _find_copysession(self, vol_instance): 'find copysession from volumename on ETERNUS.' LOG.debug('_find_copysession, volume name: %s.', vol_instance['ElementName']) try: cpsessionlist = self.conn.ReferenceNames(vol_instance.path, ResultClass='FUJITSU_StorageSynchronized') except Exception: msg = (_('_find_copysession, ReferenceNames, vol_instance: %(vol_instance_path)s, Cannot connect to ETERNUS.') % {'vol_instance_path': vol_instance.path}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_find_copysession, cpsessionlist: %(cpsessionlist)s.', {'cpsessionlist': cpsessionlist}) LOG.debug('_find_copysession, ret: %s.', cpsessionlist) return cpsessionlist def _wait_for_copy_complete(self, cpsession): 'Wait for the completion of copy.' LOG.debug('_wait_for_copy_complete, cpsession: %s.', cpsession) cpsession_instance = None while True: try: cpsession_instance = self.conn.GetInstance(cpsession, LocalOnly=False) except Exception: cpsession_instance = None if (cpsession_instance is None): break LOG.debug('_wait_for_copy_complete, find target copysession, wait for end of copysession.') if (cpsession_instance['CopyState'] == BROKEN): msg = (_('_wait_for_copy_complete, cpsession: %(cpsession)s, copysession state is BROKEN.') % {'cpsession': cpsession}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) time.sleep(10) def _delete_copysession(self, cpsession): 'delete copysession.' LOG.debug('_delete_copysession: cpssession: %s.', cpsession) try: cpsession_instance = self._get_eternus_instance(cpsession, LocalOnly=False) except Exception: LOG.info('_delete_copysession, the copysession was already completed.') return copytype = cpsession_instance['CopyType'] operation = OPERATION_dic.get(copytype, None) if (operation is None): msg = (_('_delete_copysession, copy session type is undefined! copy session: %(cpsession)s, copy type: %(copytype)s.') % {'cpsession': cpsession, 'copytype': copytype}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) repservice = self._find_eternus_service(REPL) if (repservice is None): msg = _('_delete_copysession, Cannot find Replication Service') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) (rc, errordesc, job) = self._exec_eternus_service('ModifyReplicaSynchronization', repservice, Operation=self._pywbem_uint(operation, '16'), Synchronization=cpsession, Force=True, WaitForCopyState=self._pywbem_uint(15, '16')) LOG.debug('_delete_copysession, copysession: %(cpsession)s, operation: %(operation)s, Return code: %(rc)lu, Error: %(errordesc)s.', {'cpsession': cpsession, 'operation': operation, 'rc': rc, 'errordesc': errordesc}) if (rc == COPYSESSION_NOT_EXIST): LOG.debug('_delete_copysession, cpsession: %(cpsession)s, copysession is not exist.', {'cpsession': cpsession}) elif (rc != 0): msg = (_('_delete_copysession, copysession: %(cpsession)s, operation: %(operation)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'cpsession': cpsession, 'operation': operation, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) def _get_target_port(self): 'return target portid.' LOG.debug('_get_target_port, protocol: %s.', self.protocol) target_portlist = [] if (self.protocol == 'fc'): prtcl_endpoint = 'FUJITSU_SCSIProtocolEndpoint' connection_type = 2 elif (self.protocol == 'iSCSI'): prtcl_endpoint = 'FUJITSU_iSCSIProtocolEndpoint' connection_type = 7 try: tgtportlist = self._enum_eternus_instances(prtcl_endpoint) except Exception: msg = _('_get_target_port, EnumerateInstances, cannot connect to ETERNUS.') LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for tgtport in tgtportlist: if (tgtport['ConnectionType'] != connection_type): continue if ((tgtport['RAMode'] & 123) != 0): continue if ('SCGroupNo' in tgtport): continue target_portlist.append(tgtport) LOG.debug('_get_target_port, connection type: %(cont)s, ramode: %(ramode)s.', {'cont': tgtport['ConnectionType'], 'ramode': tgtport['RAMode']}) LOG.debug('_get_target_port, target port: %(target_portid)s.', {'target_portid': target_portlist}) if (len(target_portlist) == 0): msg = (_('_get_target_port, protcol: %(protocol)s, target_port not found.') % {'protocol': self.protocol}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_get_target_port, ret: %s.', target_portlist) return target_portlist @lockutils.synchronized('ETERNUS-connect', 'cinder-', True) def _map_lun(self, vol_instance, connector, targetlist=None): 'map volume to host.' volumename = vol_instance['ElementName'] LOG.debug('_map_lun, volume name: %(vname)s, connector: %(connector)s.', {'vname': volumename, 'connector': connector}) volume_uid = vol_instance['Name'] initiatorlist = self._find_initiator_names(connector) aglist = self._find_affinity_group(connector) configservice = self._find_eternus_service(CTRL_CONF) if (targetlist is None): targetlist = self._get_target_port() if (configservice is None): msg = (_('_map_lun, vol_instance.path:%(vol)s, volumename: %(volumename)s, volume_uid: %(uid)s, initiator: %(initiator)s, target: %(tgt)s, aglist: %(aglist)s, Storage Configuration Service not found.') % {'vol': vol_instance.path, 'volumename': volumename, 'uid': volume_uid, 'initiator': initiatorlist, 'tgt': targetlist, 'aglist': aglist}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_map_lun, vol_instance.path: %(vol_instance)s, volumename:%(volumename)s, initiator:%(initiator)s, target:%(tgt)s.', {'vol_instance': vol_instance.path, 'volumename': [volumename], 'initiator': initiatorlist, 'tgt': targetlist}) if (not aglist): for target in targetlist: LOG.debug('_map_lun, lun_name: %(volume_uid)s, Initiator: %(initiator)s, target: %(target)s.', {'volume_uid': [volume_uid], 'initiator': initiatorlist, 'target': target['Name']}) (rc, errordesc, job) = self._exec_eternus_service('ExposePaths', configservice, LUNames=[volume_uid], InitiatorPortIDs=initiatorlist, TargetPortIDs=[target['Name']], DeviceAccesses=[self._pywbem_uint(2, '16')]) LOG.debug('_map_lun, Error: %(errordesc)s, Return code: %(rc)lu, Create affinitygroup and set host-affinity.', {'errordesc': errordesc, 'rc': rc}) if ((rc != 0) and (rc != LUNAME_IN_USE)): LOG.warning('_map_lun, lun_name: %(volume_uid)s, Initiator: %(initiator)s, target: %(target)s, Return code: %(rc)lu, Error: %(errordesc)s.', {'volume_uid': [volume_uid], 'initiator': initiatorlist, 'target': target['Name'], 'rc': rc, 'errordesc': errordesc}) else: for ag in aglist: LOG.debug('_map_lun, ag: %(ag)s, lun_name: %(volume_uid)s.', {'ag': ag, 'volume_uid': volume_uid}) (rc, errordesc, job) = self._exec_eternus_service('ExposePaths', configservice, LUNames=[volume_uid], DeviceAccesses=[self._pywbem_uint(2, '16')], ProtocolControllers=[ag]) LOG.debug('_map_lun, Error: %(errordesc)s, Return code: %(rc)lu, Add lun to affinity group.', {'errordesc': errordesc, 'rc': rc}) if ((rc != 0) and (rc != LUNAME_IN_USE)): LOG.warning('_map_lun, lun_name: %(volume_uid)s, Initiator: %(initiator)s, ag: %(ag)s, Return code: %(rc)lu, Error: %(errordesc)s.', {'volume_uid': [volume_uid], 'initiator': initiatorlist, 'ag': ag, 'rc': rc, 'errordesc': errordesc}) def _find_initiator_names(self, connector): 'return initiator names.' initiatornamelist = [] if ((self.protocol == 'fc') and connector['wwpns']): LOG.debug('_find_initiator_names, wwpns: %s.', connector['wwpns']) initiatornamelist = connector['wwpns'] elif ((self.protocol == 'iSCSI') and connector['initiator']): LOG.debug('_find_initiator_names, initiator: %s.', connector['initiator']) initiatornamelist.append(connector['initiator']) if (not initiatornamelist): msg = (_('_find_initiator_names, connector: %(connector)s, initiator not found.') % {'connector': connector}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_find_initiator_names, initiator list: %(initiator)s.', {'initiator': initiatornamelist}) return initiatornamelist def _find_affinity_group(self, connector, vol_instance=None): 'find affinity group from connector.' LOG.debug('_find_affinity_group, vol_instance: %s.', vol_instance) affinity_grouplist = [] initiatorlist = self._find_initiator_names(connector) if (vol_instance is None): try: aglist = self._enum_eternus_instance_names('FUJITSU_AffinityGroupController') except Exception: msg = (_('_find_affinity_group, connector: %(connector)s, EnumerateInstanceNames, cannot connect to ETERNUS.') % {'connector': connector}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_find_affinity_group,affinity_groups:%s', aglist) else: try: aglist = self._assoc_eternus_names(vol_instance.path, AssocClass='FUJITSU_ProtocolControllerForUnit', ResultClass='FUJITSU_AffinityGroupController') except Exception: msg = (_('_find_affinity_group,connector: %(connector)s,AssocNames: FUJITSU_ProtocolControllerForUnit, cannot connect to ETERNUS.') % {'connector': connector}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_find_affinity_group, vol_instance.path: %(volume)s, affinity_groups: %(aglist)s.', {'volume': vol_instance.path, 'aglist': aglist}) for ag in aglist: try: hostaglist = self._assoc_eternus(ag, AssocClass='FUJITSU_AuthorizedTarget', ResultClass='FUJITSU_AuthorizedPrivilege') except Exception: msg = (_('_find_affinity_group, connector: %(connector)s, Associators: FUJITSU_AuthorizedTarget, cannot connect to ETERNUS.') % {'connector': connector}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for hostag in hostaglist: for initiator in initiatorlist: if (initiator.lower() not in hostag['InstanceID'].lower()): continue LOG.debug('_find_affinity_group, AffinityGroup: %(ag)s.', {'ag': ag}) affinity_grouplist.append(ag) break break LOG.debug('_find_affinity_group, initiators: %(initiator)s, affinity_group: %(affinity_group)s.', {'initiator': initiatorlist, 'affinity_group': affinity_grouplist}) return affinity_grouplist @lockutils.synchronized('ETERNUS-connect', 'cinder-', True) def _unmap_lun(self, volume, connector, force=False): 'unmap volume from host.' LOG.debug('_map_lun, volume id: %(vid)s, connector: %(connector)s, force: %(frc)s.', {'vid': volume['id'], 'connector': connector, 'frc': force}) volumename = self._create_volume_name(volume['id']) vol_instance = self._find_lun(volume) if (vol_instance is None): LOG.info('_unmap_lun, volumename:%(volumename)s, volume not found.', {'volumename': volumename}) return False volume_uid = vol_instance['Name'] if (not force): aglist = self._find_affinity_group(connector, vol_instance) if (not aglist): LOG.info('_unmap_lun, volumename: %(volumename)s, volume is not mapped.', {'volumename': volumename}) return False else: try: aglist = self._assoc_eternus_names(vol_instance.path, AssocClass='CIM_ProtocolControllerForUnit', ResultClass='FUJITSU_AffinityGroupController') except Exception: msg = (_('_unmap_lun,vol_instance.path: %(volume)s, AssociatorNames: CIM_ProtocolControllerForUnit, cannot connect to ETERNUS.') % {'volume': vol_instance.path}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_unmap_lun, vol_instance.path: %(volume)s, affinity_groups: %(aglist)s.', {'volume': vol_instance.path, 'aglist': aglist}) configservice = self._find_eternus_service(CTRL_CONF) if (configservice is None): msg = (_('_unmap_lun, vol_instance.path: %(volume)s, volumename: %(volumename)s, volume_uid: %(uid)s, aglist: %(aglist)s, Controller Configuration Service not found.') % {'vol': vol_instance.path, 'volumename': [volumename], 'uid': [volume_uid], 'aglist': aglist}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for ag in aglist: LOG.debug('_unmap_lun, volumename: %(volumename)s, volume_uid: %(volume_uid)s, AffinityGroup: %(ag)s.', {'volumename': volumename, 'volume_uid': volume_uid, 'ag': ag}) (rc, errordesc, job) = self._exec_eternus_service('HidePaths', configservice, LUNames=[volume_uid], ProtocolControllers=[ag]) LOG.debug('_unmap_lun, Error: %(errordesc)s, Return code: %(rc)lu.', {'errordesc': errordesc, 'rc': rc}) if (rc == LUNAME_NOT_EXIST): LOG.debug('_unmap_lun, volumename: %(volumename)s, Invalid LUNames.', {'volumename': volumename}) elif (rc != 0): msg = (_('_unmap_lun, volumename: %(volumename)s, volume_uid: %(volume_uid)s, AffinityGroup: %(ag)s, Return code: %(rc)lu, Error: %(errordesc)s.') % {'volumename': volumename, 'volume_uid': volume_uid, 'ag': ag, 'rc': rc, 'errordesc': errordesc}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_unmap_lun, volumename: %(volumename)s.', {'volumename': volumename}) return True def _get_eternus_iscsi_properties(self): 'get target port iqns and target_portals.' iscsi_properties_list = [] iscsiip_list = self._get_drvcfg('EternusISCSIIP', multiple=True) iscsi_port = self.configuration.iscsi_port LOG.debug('_get_eternus_iscsi_properties, iplist: %s.', iscsiip_list) try: ip_endpointlist = self._enum_eternus_instance_names('FUJITSU_IPProtocolEndpoint') except Exception: msg = (_('_get_eternus_iscsi_properties, iscsiip: %(iscsiip)s, EnumerateInstanceNames, cannot connect to ETERNUS.') % {'iscsiip': iscsiip_list}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for ip_endpoint in ip_endpointlist: try: ip_endpoint_instance = self._get_eternus_instance(ip_endpoint) ip_address = ip_endpoint_instance['IPv4Address'] LOG.debug('_get_eternus_iscsi_properties, instanceip: %(ip)s, iscsiip: %(iscsiip)s.', {'ip': ip_address, 'iscsiip': iscsiip_list}) except Exception: msg = (_('_get_eternus_iscsi_properties, iscsiip: %(iscsiip)s, GetInstance, cannot connect to ETERNUS.') % {'iscsiip': iscsiip_list}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) if (ip_address not in iscsiip_list): continue LOG.debug('_get_eternus_iscsi_properties, find iscsiip: %(ip)s.', {'ip': ip_address}) try: tcp_endpointlist = self._assoc_eternus_names(ip_endpoint, AssocClass='CIM_BindsTo', ResultClass='FUJITSU_TCPProtocolEndpoint') except Exception: msg = (_('_get_eternus_iscsi_properties, iscsiip: %(iscsiip)s, AssociatorNames: CIM_BindsTo, cannot connect to ETERNUS.') % {'iscsiip': ip_address}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for tcp_endpoint in tcp_endpointlist: try: iscsi_endpointlist = self._assoc_eternus(tcp_endpoint, AssocClass='CIM_BindsTo', ResultClass='FUJITSU_iSCSIProtocolEndpoint') except Exception: msg = (_('_get_eternus_iscsi_properties, iscsiip: %(iscsiip)s, AssociatorNames: CIM_BindsTo, cannot connect to ETERNUS.') % {'iscsiip': ip_address}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) for iscsi_endpoint in iscsi_endpointlist: target_portal = ('%s:%s' % (ip_address, iscsi_port)) iqn = iscsi_endpoint['Name'].split(',')[0] iscsi_properties_list.append((iscsi_endpoint.path, target_portal, iqn)) LOG.debug('_get_eternus_iscsi_properties, target_portal: %(target_portal)s, iqn: %(iqn)s.', {'target_portal': target_portal, 'iqn': iqn}) if (len(iscsi_properties_list) == 0): msg = (_('_get_eternus_iscsi_properties, iscsiip list: %(iscsiip_list)s, iqn not found.') % {'iscsiip_list': iscsiip_list}) LOG.error(msg) raise exception.VolumeBackendAPIException(data=msg) LOG.debug('_get_eternus_iscsi_properties, iscsi_properties_list: %(iscsi_properties_list)s.', {'iscsi_properties_list': iscsi_properties_list}) return iscsi_properties_list def _wait_for_job_complete(self, conn, job): 'Given the job wait for it to complete.' self.retries = 0 self.wait_for_job_called = False def _wait_for_job_complete(): 'Called at an interval until the job is finished.' if self._is_job_finished(conn, job): raise loopingcall.LoopingCallDone() if (self.retries > JOB_RETRIES): LOG.error('_wait_for_job_complete, failed after %(retries)d tries.', {'retries': self.retries}) raise loopingcall.LoopingCallDone() try: self.retries += 1 if (not self.wait_for_job_called): if self._is_job_finished(conn, job): self.wait_for_job_called = True except Exception: exceptionMessage = _('Issue encountered waiting for job.') LOG.exception(exceptionMessage) raise exception.VolumeBackendAPIException(exceptionMessage) self.wait_for_job_called = False timer = loopingcall.FixedIntervalLoopingCall(_wait_for_job_complete) timer.start(interval=JOB_INTERVAL_SEC).wait() jobInstanceName = job['Job'] jobinstance = conn.GetInstance(jobInstanceName, LocalOnly=False) rc = jobinstance['ErrorCode'] LOG.debug('_wait_for_job_complete, rc: %s.', rc) return rc def _is_job_finished(self, conn, job): 'Check if the job is finished.' jobInstanceName = job['Job'] jobinstance = conn.GetInstance(jobInstanceName, LocalOnly=False) jobstate = jobinstance['JobState'] LOG.debug('_is_job_finished,state: %(state)s', {'state': jobstate}) if (jobstate in [2, 3, 4]): job_finished = False else: job_finished = True LOG.debug('_is_job_finished, finish: %s.', job_finished) return job_finished def _pywbem_uint(self, num, datatype): try: result = {'8': pywbem.Uint8(num), '16': pywbem.Uint16(num), '32': pywbem.Uint32(num), '64': pywbem.Uint64(num)} result = result.get(datatype, num) except NameError: result = num return result
import random, binascii, threading, os, time
def pycc_corrupt_string(string):
if string:
if (random.randint(0, 1) == 0):
hexstring = binascii.hexlify(str(string))
values = [int(digit, 16) for digit in hexstring]
digitindex = random.randint(0, len(values))
bitindex = random.randint(0, 3)
values[(digitindex - 1)] ^= (1 << bitindex)
result = ''.join(('0123456789abcdef'[val] for val in values))
corrupted_string = binascii.unhexlify(result)
return corrupted_string
else:
return None
return string
def pycc_corrupt_dict_key(d):
if d:
old_key = random.choice(d.keys())
corrupted_key = pycc_corrupt(old_key)
d[corrupted_key] = d.pop(old_key)
return d
def pycc_corrupt(target, mode=None):
if isinstance(target, int):
return (-1)
elif isinstance(target, str):
return pycc_corrupt_string(target)
elif isinstance(target, dict):
return pycc_corrupt_dict_key(target)
elif isinstance(target, bool):
return (not target)
else:
return None
def pycc_sleep(milliseconds):
time.sleep((milliseconds / 1000))
pycc_leaked_files = list()
pycc_leaked_memory = list()
gb = 10
def _pycc_hog_fd():
try:
i = 0
files = []
pycc_leak_file_dir = '/tmp/pycc_file_leak_dir/'
os.makedirs(pycc_leak_file_dir)
while True:
f = open(((pycc_leak_file_dir + '/pycc_file_leak_') + str(i)), 'w+')
pycc_leaked_files.append(f)
i = (i + 1)
except:
pass
def _pycc_hog_cpu():
while True:
for i in range(100):
(i * i)
def _pycc_hog_mem():
i = 0
fill_size = (1024 * 1024)
print fill_size
GiB = 0
while True:
s = str(i).zfill(fill_size)
pycc_leaked_memory.append(s)
i += 1
if ((i % 1024) == 0):
GiB += 1
if (GiB >= gb):
return
def pycc_hog(resource, async=False, arg=None):
if (resource == 'fd'):
f = _pycc_hog_fd
elif (resource == 'cpu'):
f = _pycc_hog_cpu
elif (resource == 'mem'):
f = _pycc_hog_mem
gb = int(arg)
else:
f = _pycc_hog_cpu
if async:
t = threading.Thread(target=f)
t.start()
else:
f()
'\nCinder Volume driver for Fujitsu ETERNUS DX S3 series.\n'
import ast
import base64
import hashlib
import six
import time
from xml.etree.ElementTree import parse
from cinder import exception
from cinder.i18n import _
from cinder.volume import configuration as conf

Xet Storage Details

Size:
67 kB
·
Xet hash:
01f7288923a182e938f316de7573b384ef1dbe511d9a8189f2b086ec7e3bc281

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.