Beispiel #1
0
 def get_volume_stats(self, refresh=False):
     if refresh:
         if self.storage_info['output_first']:
             self.storage_info['output_first'] = False
             utils.output_log(3, config_group=self.conf.config_group)
         self._update_volume_stats()
     return self._stats
Beispiel #2
0
 def _run_add_lun(self, ldev, port, gid, lun=None):
     args = ['add', 'lun', '-port', '-'.join([port, gid]), '-ldev_id', ldev]
     ignore_error = [_LU_PATH_DEFINED]
     if lun:
         args.extend(['-lun_id', lun])
         ignore_error = [_ANOTHER_LDEV_MAPPED]
     result = self.run_raidcom(
         *args, ignore_error=ignore_error,
         interval=_LUN_RETRY_INTERVAL, timeout=_LUN_MAX_WAITTIME)
     if not lun:
         if result[0] == EX_CMDRJE:
             lun = self._find_lun(ldev, port, gid)
             LOG.debug(
                 'An logical unit path has already defined in the '
                 'specified logical device. (LDEV: %s, port: %s, gid: %s, '
                 'lun: %s)', ldev, port, gid, lun)
         else:
             lun = find_value(result[1], 'lun')
     elif _ANOTHER_LDEV_MAPPED in result[2]:
         utils.output_log(314, ldev=ldev, port=port, id=gid, lun=lun)
         return None
     LOG.debug(
         'Created logical unit path to the specified logical device. '
         '(LDEV: %s, port: %s, gid: %s, lun: %s)', ldev, port, gid, lun)
     return lun
Beispiel #3
0
 def output_param_to_log(self):
     utils.output_log(1, config_group=self.conf.config_group)
     name, version = self.get_storage_cli_info()
     utils.output_storage_cli_info(name, version)
     utils.output_opt_info(self.conf, _INHERITED_VOLUME_OPTS)
     utils.output_opts(self.conf, opts.COMMON_VOLUME_OPTS)
     utils.output_opts(self.conf, self.driver_info['volume_opts'])
Beispiel #4
0
 def _delete_ldev_from_storage(self, ldev):
     result = self.run_raidcom(
         'get', 'ldev', '-ldev_id', ldev, *_LDEV_DELETED, do_raise=False)
     if not result[0]:
         utils.output_log(319, ldev=ldev)
         return
     self.run_raidcom('delete', 'ldev', '-ldev_id', ldev)
Beispiel #5
0
 def discard_zero_page(self, volume):
     ldev = utils.get_ldev(volume)
     try:
         self.run_raidcom(
             'modify', 'ldev', '-ldev_id', ldev,
             '-status', 'discard_zero_page')
     except exception.HPEXPError:
         utils.output_log(315, ldev=ldev)
Beispiel #6
0
 def copy_dest_vol_meta_to_src_vol(self, src_vol, dest_vol):
     metadata = utils.get_volume_metadata(dest_vol)
     try:
         self.db.volume_metadata_update(
             self.ctxt, src_vol['id'], metadata, True)
     except Exception as ex:
         utils.output_log(
             318, src_vol_id=src_vol['id'], dest_vol_id=dest_vol['id'],
             reason=six.text_type(ex))
Beispiel #7
0
 def map_ldev(self, targets, ldev):
     port, gid = targets['list'][0]
     lun = self._run_add_lun(ldev, port, gid)
     for port, gid in targets['list'][1:]:
         try:
             self._run_add_lun(ldev, port, gid, lun=lun)
         except exception.HPEXPError:
             utils.output_log(314, ldev=ldev, port=port, id=gid, lun=lun)
     return lun
Beispiel #8
0
 def _start_horcmgr(self, horcmgr):
     inst = self.conf.hpexp_horcm_numbers[horcmgr]
     ret = 0
     if _run_horcmgr(inst) != _HORCM_RUNNING:
         ret = _run_horcmstart(inst)
     if ret and ret != _HORCM_RUNNING:
         utils.output_log(320, inst=inst)
         return False
     return True
Beispiel #9
0
    def _retry_login(self, ignore_enauth, do_login):
        if not ignore_enauth:
            if not do_login:
                result = self._run_raidcom_login(do_raise=False)

            if do_login or result[0]:
                utils.output_log(323, user=self.conf.hpexp_horcm_user)
                return False

        return True
Beispiel #10
0
 def get_copy_method(self, metadata):
     method = metadata.get(
         'copy_method', self.conf.hpexp_default_copy_method)
     if method not in _COPY_METHOD:
         msg = utils.output_log(602, meta='copy_method')
         raise exception.HPEXPError(data=msg)
     if method == 'THIN' and not self.conf.hpexp_thin_pool:
         msg = utils.output_log(601, param='hpexp_thin_pool')
         raise exception.HPEXPError(data=msg)
     return method
Beispiel #11
0
 def _copy_on_host(self, src_ldev, size):
     dest_ldev = self.create_ldev(size)
     try:
         self._copy_with_dd(src_ldev, dest_ldev, size)
     except Exception:
         with excutils.save_and_reraise_exception():
             try:
                 self._delete_ldev(dest_ldev)
             except exception.HPEXPError:
                 utils.output_log(313, ldev=dest_ldev)
     return dest_ldev, utils.NORMAL_LDEV_TYPE
Beispiel #12
0
    def _initialize_pair_connection(self, ldev):
        port, gid = None, None

        for port, gid in self._pair_targets:
            try:
                return self.map_ldev({'list': [(port, gid)]}, ldev)
            except exception.HPEXPError:
                utils.output_log(314, ldev=ldev, port=port, id=gid, lun=None)

        msg = utils.output_log(639, ldev=ldev)
        raise exception.HPEXPError(msg)
Beispiel #13
0
 def _detach_ldev(self, attach_info, ldev, properties):
     volume = {
         'provider_location': six.text_type(ldev),
     }
     connector = attach_info['connector']
     try:
         connector.disconnect_volume(
             attach_info['conn']['data'], attach_info['device'])
     except Exception as ex:
         utils.output_log(329, ldev=ldev, reason=six.text_type(ex))
     self._terminate_connection(volume, properties)
Beispiel #14
0
 def delete_volume(self, volume):
     ldev = utils.get_ldev(volume)
     # When 'ldev' is 0, it should be true.
     # Therefore, it cannot remove 'is not None'.
     if ldev is None:
         utils.output_log(304, method='delete_volume', id=volume['id'])
         return
     try:
         self._delete_ldev(ldev)
     except exception.HPEXPBusy:
         raise exception.HPEXPVolumeIsBusy(volume_name=volume['name'])
Beispiel #15
0
 def extend_volume(self, volume, new_size):
     ldev = utils.get_ldev(volume)
     # When 'ldev' is 0, it should be true.
     # Therefore, it cannot remove 'is None'.
     if ldev is None:
         msg = utils.output_log(613, volume_id=volume['id'])
         raise exception.HPEXPError(data=msg)
     if self.check_vvol(ldev):
         msg = utils.output_log(618, volume_id=volume['id'])
         raise exception.HPEXPError(data=msg)
     self.delete_pair(ldev)
     self.extend_ldev(ldev, volume['size'], new_size)
Beispiel #16
0
 def create_volume(self, volume):
     try:
         ldev = self.create_ldev(volume['size'])
     except Exception:
         with excutils.save_and_reraise_exception():
             utils.output_log(636)
     metadata = volume.get('metadata', {})
     return {
         'provider_location': six.text_type(ldev),
         'metadata': dict(
             metadata, ldev=ldev, type=utils.NORMAL_LDEV_TYPE),
     }
Beispiel #17
0
 def delete_snapshot(self, snapshot):
     ldev = utils.get_ldev(snapshot)
     # When 'ldev' is 0, it should be true.
     # Therefore, it cannot remove 'is None'.
     if ldev is None:
         utils.output_log(
             304, method='delete_snapshot', id=snapshot['id'])
         return
     try:
         self._delete_ldev(ldev)
     except exception.HPEXPBusy:
         raise exception.HPEXPSnapshotIsBusy(snapshot_name=snapshot['name'])
Beispiel #18
0
 def copy_on_storage(self, pvol, size, metadata):
     is_thin = self.get_copy_method(metadata) == "THIN"
     ldev_type = utils.VVOL_LDEV_TYPE if is_thin else utils.NORMAL_LDEV_TYPE
     svol = self.create_ldev(size, is_vvol=is_thin)
     try:
         self.create_pair_on_storage(pvol, svol, is_thin)
     except Exception:
         with excutils.save_and_reraise_exception():
             try:
                 self._delete_ldev(svol)
             except exception.HPEXPError:
                 utils.output_log(313, ldev=svol)
     return svol, ldev_type
Beispiel #19
0
 def manage_existing_get_size(self, dummy_volume, existing_ref):
     if existing_ref.get('storage_id') != self.conf.hpexp_storage_id:
         msg = utils.output_log(700, param='storage_id')
         raise exception.ManageExistingInvalidReference(
             existing_ref=existing_ref, reason=msg)
     ldev = _str2int(existing_ref.get('ldev'))
     # When 'ldev' is 0, it should be true.
     # Therefore, it cannot remove 'is None'.
     if ldev is None:
         msg = utils.output_log(701)
         raise exception.ManageExistingInvalidReference(
             existing_ref=existing_ref, reason=msg)
     return self.get_ldev_size_in_gigabyte(ldev, existing_ref)
Beispiel #20
0
 def set_hba_ids(self, port, gid, hba_ids):
     registered_wwns = []
     for wwn in hba_ids:
         try:
             self.run_raidcom(
                 'add', 'hba_wwn', '-port',
                 '-'.join([port, gid]), '-hba_wwn', wwn)
             registered_wwns.append(wwn)
         except exception.HPEXPError:
             utils.output_log(317, port=port, gid=gid, wwn=wwn)
     if not registered_wwns:
         msg = utils.output_log(614, port=port, gid=gid)
         raise exception.HPEXPError(msg)
Beispiel #21
0
    def create_mapping_targets(self, targets, connector):
        hba_ids = self.get_hba_ids_from_connector(connector)
        for port in targets['info'].keys():
            if targets['info'][port]:
                continue

            try:
                self._create_target(targets, port, connector['ip'], hba_ids)
            except exception.HPEXPError:
                utils.output_log(
                    self.driver_info['msg_id']['target'], port=port)

        if not targets['list']:
            self.find_targets_from_storage(
                targets, connector, targets['info'].keys())
Beispiel #22
0
 def unmanage(self, volume):
     ldev = utils.get_ldev(volume)
     # When 'ldev' is 0, it should be true.
     # Therefore, it cannot remove 'is None'.
     if ldev is None:
         utils.output_log(304, method='unmanage', id=volume['id'])
         return
     if self.check_vvol(ldev):
         utils.output_log(
             706, volume_id=volume['id'],
             volume_type=utils.NORMAL_LDEV_TYPE)
         raise exception.HPEXPVolumeIsBusy(volume_name=volume['name'])
     try:
         self.delete_pair(ldev)
     except exception.HPEXPBusy:
         raise exception.HPEXPVolumeIsBusy(volume_name=volume['name'])
Beispiel #23
0
    def _create_horcm_conf(self, horcmgr=_HORCMGR):
        inst = self.conf.hpexp_horcm_numbers[horcmgr]
        inst = int(inst)
        serial = self.conf.hpexp_storage_id
        filename = '/etc/horcm%s.conf' % inst
        port = _DEFAULT_PORT_BASE + inst
        found = False
        if not os.path.exists(filename):
            file_str = """
HORCM_MON
#ip_address        service         poll(10ms)     timeout(10ms)
127.0.0.1 %16d               6000              3000
HORCM_CMD
""" % port
        else:
            file_str = cinder_utils.read_file_as_root(filename)
            if re.search(r'^\\\\.\\CMD-%s:/dev/sd$' % serial, file_str, re.M):
                found = True
        if not found:
            repl_str = r'\1\\\\.\\CMD-%s:/dev/sd\n' % serial
            file_str = CMD_PATTERN.sub(repl_str, file_str)
            result = utils.execute('tee', filename, process_input=file_str)
            if result[0]:
                msg = utils.output_log(
                    632, file=filename, ret=result[0], err=result[2])
                raise exception.HPEXPError(data=msg)
Beispiel #24
0
    def delete_pair_based_on_pvol(self, pair_info, all_split):
        svols = []
        restart = False

        try:
            for svol_info in pair_info['svol_info']:
                if svol_info['is_thin'] or not svol_info['is_psus']:
                    svols.append(six.text_type(svol_info['ldev']))
                    continue

                self.delete_pair_from_storage(
                    pair_info['pvol'], svol_info['ldev'], False)

                restart = True

                self._terminate_pair_connection(svol_info['ldev'])

            if not svols:
                self._terminate_pair_connection(pair_info['pvol'])

        finally:
            if restart:
                self._restart_horcmgr(_PAIR_HORCMGR)

        if all_split and svols:
            msg = utils.output_log(
                616, pvol=pair_info['pvol'], svol=', '.join(svols))
            raise exception.HPEXPBusy(message=msg)
Beispiel #25
0
 def check_param(self):
     utils.check_opt_value(self.conf, _INHERITED_VOLUME_OPTS)
     utils.check_opts(self.conf, opts.COMMON_VOLUME_OPTS)
     utils.check_opts(self.conf, _COMMON_VOLUME_OPTS)
     utils.check_opts(self.conf, self.driver_info['volume_opts'])
     if self.conf.hpexp_default_copy_method not in _COPY_METHOD:
         msg = utils.output_log(
             601, param='hpexp_default_copy_method')
         raise exception.HPEXPError(data=msg)
     if (self.conf.hpexp_default_copy_method == 'THIN' and
             not self.conf.hpexp_thin_pool):
         msg = utils.output_log(601, param='hpexp_thin_pool')
         raise exception.HPEXPError(data=msg)
     if self.conf.hpexp_ldev_range:
         self.storage_info['ldev_range'] = self._range2list(
             'hpexp_ldev_range')
Beispiel #26
0
 def _range2list(self, param):
     values = [_str2int(x) for x in self.conf.safe_get(param).split('-')]
     if (len(values) != 2 or
             values[0] is None or values[1] is None or
             values[0] > values[1]):
         msg = utils.output_log(601, param=param)
         raise exception.HPEXPError(data=msg)
     return values
Beispiel #27
0
 def connect_storage(self):
     self.storage_info['pool_id'] = self.get_pool_id()
     # When 'pool_id' is 0, it should be true.
     # Therefore, it cannot remove 'is None'.
     if self.storage_info['pool_id'] is None:
         msg = utils.output_log(640, pool=self.conf.hpexp_pool)
         raise exception.HPEXPError(data=msg)
     LOG.debug('Setting pool id: %s', self.storage_info['pool_id'])
Beispiel #28
0
    def copy_on_storage(self, pvol, size, metadata):
        ldev_info = self.get_ldev_info(['sts', 'vol_attr'], '-ldev_id', pvol)
        if ldev_info['sts'] != NORMAL_STS:
            msg = utils.output_log(612, ldev=pvol)
            raise exception.HPEXPError(data=msg)

        if VVOL_ATTR in ldev_info['vol_attr']:
            raise exception.HPEXPNotImplementedError()
        return super(HPEXPHORCM, self).copy_on_storage(pvol, size, metadata)
Beispiel #29
0
 def check_param(self):
     super(HPEXPHORCM, self).check_param()
     utils.check_opts(self.conf, opts.HORCM_VOLUME_OPTS)
     utils.check_opts(self.conf, _HORCM_VOLUME_OPTS)
     utils.check_opt_value(CONF, _HORCM_OPT_NAMES)
     insts = self.conf.hpexp_horcm_numbers
     if len(insts) != 2 or insts[_HORCMGR] == insts[_PAIR_HORCMGR]:
         msg = utils.output_log(601, param='hpexp_horcm_numbers')
         raise exception.HPEXPError(data=msg)
     LOG.debug('Setting ldev_range: %s', self.storage_info['ldev_range'])
Beispiel #30
0
 def _create_thin_copy_pair(self, pvol, svol, dummy_vol_type):
     snapshot_name = _SNAP_NAME + six.text_type(svol % _SNAP_HASH_SIZE)
     self.run_raidcom(
         'add', 'snapshot', '-ldev_id', pvol, svol, '-pool',
         self.conf.hpexp_thin_pool, '-snapshot_name',
         snapshot_name, '-copy_size', self.conf.hpexp_copy_speed)
     try:
         self.wait_thin_copy(svol, PAIR)
         self.run_raidcom(
             'modify', 'snapshot', '-ldev_id', svol,
             '-snapshot_data', 'create')
         self.wait_thin_copy(svol, PSUS)
     except Exception:
         with excutils.save_and_reraise_exception():
             interval = self.conf.hpexp_async_copy_check_interval
             try:
                 self._delete_thin_copy_pair(pvol, svol, interval)
             except exception.HPEXPError:
                 utils.output_log(325, pvol=pvol, svol=svol)