def delete_volume(self, volume):
ldev = self.get_ldev(volume)
if ldev is None:
LOG.warning(basic_lib.set_msg(304, method='delete_volume',
id=volume['id']))
return
self.add_volinfo(ldev, volume['id'])
if not self.volume_info[ldev]['in_use'].lock.acquire(False):
desc = self.volume_info[ldev]['in_use'].desc
basic_lib.output_err(660, desc=desc)
raise exception.VolumeIsBusy(volume_name=volume['name'])
try:
is_vvol = self.get_volume_is_vvol(volume)
try:
self.delete_ldev(ldev, is_vvol)
except exception.HBSDNotFound:
with self.volinfo_lock:
if ldev in self.volume_info:
self.volume_info.pop(ldev)
LOG.warning(basic_lib.set_msg(
305, type='volume', id=volume['id']))
except exception.HBSDBusy:
raise exception.VolumeIsBusy(volume_name=volume['name'])
finally:
if ldev in self.volume_info:
self.volume_info[ldev]['in_use'].lock.release()
def delete_snapshot(self, snapshot):
ldev = self.get_ldev(snapshot)
if ldev is None:
msg = basic_lib.set_msg(
304, method='delete_snapshot', id=snapshot['id'])
LOG.warning(msg)
return
self.add_volinfo(ldev, id=snapshot['id'], type='snapshot')
if not self.volume_info[ldev]['in_use'].lock.acquire(False):
desc = self.volume_info[ldev]['in_use'].desc
basic_lib.output_err(660, desc=desc)
raise exception.SnapshotIsBusy(snapshot_name=snapshot['name'])
try:
is_vvol = self.get_snapshot_is_vvol(snapshot)
try:
self.delete_ldev(ldev, is_vvol)
except exception.HBSDNotFound:
with self.volinfo_lock:
if ldev in self.volume_info:
self.volume_info.pop(ldev)
msg = basic_lib.set_msg(
305, type='snapshot', id=snapshot['id'])
LOG.warning(msg)
except exception.HBSDBusy:
raise exception.SnapshotIsBusy(snapshot_name=snapshot['name'])
finally:
if ldev in self.volume_info:
self.volume_info[ldev]['in_use'].lock.release()
def _fill_groups(self, hgs, ports, target_iqn, target_alias, add_iqn):
for port in ports:
added_hostgroup = False
added_user = False
LOG.debug('Create target (hgs: %(hgs)s port: %(port)s '
'target_iqn: %(tiqn)s target_alias: %(alias)s '
'add_iqn: %(aiqn)s)' %
{'hgs': hgs, 'port': port, 'tiqn': target_iqn,
'alias': target_alias, 'aiqn': add_iqn})
gid = self.common.command.get_gid_from_targetiqn(
target_iqn, target_alias, port)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
gid = None
try:
gid = self._get_unused_gid_iscsi(port)
self.common.command.comm_add_hostgrp_iscsi(
port, gid, target_alias, target_iqn)
added_hostgroup = True
except exception.HBSDNotFound:
msg = basic_lib.set_msg(312, resource='GID')
LOG.warning(msg)
continue
except Exception as ex:
msg = basic_lib.set_msg(
309, port=port, alias=target_alias,
reason=six.text_type(ex))
LOG.warning(msg)
break
else:
LOG.debug('Completed to add target'
'(port: %(port)s gid: %(gid)d)'
% {'port': port, 'gid': gid})
break
if gid is None:
LOG.error(_LE('Failed to add target(port: %s)') % port)
continue
try:
if added_hostgroup:
if self.configuration.hitachi_auth_method:
added_user = self.common.command.set_chap_authention(
port, gid)
self.common.command.comm_set_hostgrp_reportportal(
port, target_alias)
self._add_initiator(hgs, port, gid, add_iqn)
except Exception as ex:
msg = basic_lib.set_msg(
316, port=port, reason=six.text_type(ex))
LOG.warning(msg)
if added_hostgroup:
if added_user:
self._delete_chap_user(port)
self._delete_iscsi_target(port, gid, target_alias)
def output_param_to_log(self, storage_protocol):
essential_inherited_param = ['volume_backend_name', 'volume_driver']
conf = self.configuration
msg = basic_lib.set_msg(1, config_group=conf.config_group)
LOG.info(msg)
version = self.command.get_comm_version()
if conf.hitachi_unit_name:
prefix = 'HSNM2 version'
else:
prefix = 'RAID Manager version'
LOG.info('\t%-35s%s' % (prefix + ': ', six.text_type(version)))
for param in essential_inherited_param:
value = conf.safe_get(param)
LOG.info('\t%-35s%s' % (param + ': ', six.text_type(value)))
for opt in volume_opts:
if not opt.secret:
value = getattr(conf, opt.name)
LOG.info('\t%-35s%s' % (opt.name + ': ',
six.text_type(value)))
if storage_protocol == 'iSCSI':
value = getattr(conf, 'hitachi_group_request')
LOG.info('\t%-35s%s' % ('hitachi_group_request: ',
six.text_type(value)))
def add_hostgroup_master(self, hgs, master_wwns, host_ip, security_ports):
target_ports = self.configuration.hitachi_target_ports
group_request = self.configuration.hitachi_group_request
wwns = []
for wwn in master_wwns:
wwns.append(wwn.lower())
if target_ports and group_request:
host_grp_name = '%s%s' % (basic_lib.NAME_PREFIX, host_ip)
for port in security_ports:
wwns_copy = wwns[:]
for hostgroup in hgs:
if (hostgroup['port'] == port and
hostgroup['initiator_wwn'].lower() in wwns_copy):
wwns_copy.remove(hostgroup['initiator_wwn'].lower())
if wwns_copy:
try:
self._fill_group(hgs, port, host_grp_name, wwns_copy)
except Exception as ex:
LOG.warning(_('Failed to add host group: %s') %
six.text_type(ex))
msg = basic_lib.set_msg(
308, port=port, name=host_grp_name)
LOG.warning(msg)
if not hgs:
msg = basic_lib.output_err(649)
raise exception.HBSDError(message=msg)
def _delete_iscsi_target(self, port, target_no, target_alias):
ret, _stdout, _stderr = self.common.command.delete_iscsi_target(
port, target_no, target_alias)
if ret:
msg = basic_lib.set_msg(
307, port=port, tno=target_no, alias=target_alias)
LOG.warning(msg)
def terminate_connection(self, volume, connector, **kwargs):
self.do_setup_status.wait()
ldev = self.common.get_ldev(volume)
if ldev is None:
msg = basic_lib.set_msg(302, volume_id=volume["id"])
LOG.warning(msg)
return
if "wwpns" not in connector:
msg = basic_lib.output_err(650, resource="HBA")
raise exception.HBSDError(message=msg)
hostgroups = []
self._get_hostgroup_info(hostgroups, connector["wwpns"], login=False)
if not hostgroups:
msg = basic_lib.output_err(649)
raise exception.HBSDError(message=msg)
self.common.add_volinfo(ldev, volume["id"])
with nested(self.common.volume_info[ldev]["lock"], self.common.volume_info[ldev]["in_use"]):
self._terminate_connection(ldev, connector, hostgroups)
properties = self._get_properties(volume, hostgroups, terminate=True)
LOG.debug("Terminate volume_info: %s" % self.common.volume_info)
return {"driver_volume_type": "fibre_channel", "data": properties}
def unmanage(self, volume):
"""Remove the specified volume from Cinder management."""
ldev = self.get_ldev(volume)
if ldev is None:
return
self.add_volinfo(ldev, volume['id'])
if not self.volume_info[ldev]['in_use'].lock.acquire(False):
desc = self.volume_info[ldev]['in_use'].desc
basic_lib.output_err(660, desc=desc)
raise exception.HBSDVolumeIsBusy(volume_name=volume['name'])
is_vvol = self.get_volume_is_vvol(volume)
if is_vvol:
basic_lib.output_err(706, volume_id=volume['id'],
volume_type=basic_lib.NORMAL_VOLUME_TYPE)
raise exception.HBSDVolumeIsBusy(volume_name=volume['name'])
try:
self._unmanage(volume, ldev)
except exception.HBSDBusy:
raise exception.HBSDVolumeIsBusy(volume_name=volume['name'])
else:
msg = basic_lib.set_msg(5, volume_id=volume['id'], ldev=ldev)
LOG.info(msg)
finally:
if ldev in self.volume_info:
self.volume_info[ldev]['in_use'].lock.release()
def _delete_hostgroup(self, port, gid, host_grp_name):
try:
self.common.command.comm_del_hostgrp(port, gid, host_grp_name)
except Exception:
with excutils.save_and_reraise_exception():
LOG.warning(basic_lib.set_msg(
306, port=port, gid=gid, name=host_grp_name))
def _initialize_connection(self, ldev, connector, src_hgs=None):
LOG.debug("Call _initialize_connection "
"(config_group: %(group)s ldev: %(ldev)d)",
{'group': self.configuration.config_group, 'ldev': ldev})
if src_hgs is self.pair_hostgroups:
hostgroups = src_hgs
else:
hostgroups = []
security_ports = self._get_hostgroup_info(
hostgroups, connector['wwpns'], login=True)
self.add_hostgroup_master(hostgroups, connector['wwpns'],
connector['ip'], security_ports)
if src_hgs is self.pair_hostgroups:
try:
self._add_lun(hostgroups, ldev)
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(311, ldev=ldev))
for i in range(self.max_hostgroups + 1):
self.pair_hostnum += 1
pair_hostgroups = []
try:
self.add_hostgroup_pair(pair_hostgroups)
self.pair_hostgroups.extend(pair_hostgroups)
except exception.HBSDNotFound:
if i >= self.max_hostgroups:
msg = basic_lib.output_err(648, resource='GID')
raise exception.HBSDError(message=msg)
else:
break
self.pair_initialize_connection(ldev)
else:
self._add_lun(hostgroups, ldev)
return hostgroups
def manage_existing(self, volume, existing_ref):
"""Manage an existing Hitachi storage volume.
existing_ref is a dictionary of the form:
For HUS 100 Family:
.. code-block:: default
{
'ldev': <logical device number on storage>,
'unit_name': <storage device name>
}
For VSP G1000/VSP/HUS VM:
.. code-block:: default
{
'ldev': <logical device number on storage>,
'serial_number': <product number of storage system>
}
"""
ldev = self._string2int(existing_ref.get('ldev'))
LOG.info(basic_lib.set_msg(4, volume_id=volume['id'], ldev=ldev))
return {'provider_location': ldev}
def output_param_to_log(self, storage_protocol):
essential_inherited_param = ['volume_backend_name', 'volume_driver']
conf = self.configuration
LOG.info(basic_lib.set_msg(1, config_group=conf.config_group))
version = self.command.get_comm_version()
if conf.hitachi_unit_name:
prefix = 'HSNM2 version'
else:
prefix = 'RAID Manager version'
LOG.info(_LI('\t%(prefix)-35s : %(version)s'),
{'prefix': prefix, 'version': version})
for param in essential_inherited_param:
value = conf.safe_get(param)
LOG.info(_LI('\t%(param)-35s : %(value)s'),
{'param': param, 'value': value})
for opt in volume_opts:
if not opt.secret:
value = getattr(conf, opt.name)
LOG.info(_LI('\t%(name)-35s : %(value)s'),
{'name': opt.name, 'value': value})
if storage_protocol == 'iSCSI':
value = getattr(conf, 'hitachi_group_request')
LOG.info(_LI('\t%(request)-35s : %(value)s'),
{'request': 'hitachi_group_request', 'value': value})
def terminate_connection(self, volume, connector, **kwargs):
self.do_setup_status.wait()
ldev = self.common.get_ldev(volume)
if ldev is None:
LOG.warning(basic_lib.set_msg(302, volume_id=volume['id']))
return
if 'wwpns' not in connector:
msg = basic_lib.output_err(650, resource='HBA')
raise exception.HBSDError(message=msg)
hostgroups = []
self._get_hostgroup_info(hostgroups,
connector['wwpns'], login=False)
if not hostgroups:
msg = basic_lib.output_err(649)
raise exception.HBSDError(message=msg)
self.common.add_volinfo(ldev, volume['id'])
with self.common.volume_info[ldev]['lock'],\
self.common.volume_info[ldev]['in_use']:
self._terminate_connection(ldev, connector, hostgroups)
properties = self._get_properties(volume, hostgroups,
terminate=True)
LOG.debug('Terminate volume_info: %s', self.common.volume_info)
return {
'driver_volume_type': 'fibre_channel',
'data': properties
}
def set_chap_authention(self, port, gid):
ctl_no = port[0]
port_no = port[1]
unit = self.unit_name
auth_username = self.conf.hitachi_auth_user
auth_password = self.conf.hitachi_auth_password
add_chap_user = self.conf.hitachi_add_chap_user
assign_flag = True
added_flag = False
opt = "-unit %s -refer %s %s -user %s" % (unit, ctl_no, port_no, auth_username)
ret, stdout, stderr = self.exec_hsnm("auchapuser", opt, noretry=True)
if ret:
if not add_chap_user:
msg = basic_lib.output_err(643, user=auth_username)
raise exception.HBSDError(message=msg)
root_helper = utils.get_root_helper()
cmd = "%s env %s auchapuser -unit %s -add %s %s " "-tno %d -user %s" % (
root_helper,
SNM2_ENV,
unit,
ctl_no,
port_no,
gid,
auth_username,
)
LOG.debug("Add CHAP user")
loop = loopingcall.FixedIntervalLoopingCall(
self._wait_for_add_chap_user, cmd, auth_username, auth_password, time.time()
)
added_flag = loop.start(interval=EXEC_INTERVAL).wait()
else:
lines = stdout.splitlines()[4:]
for line in lines:
if int(shlex.split(line)[0][0:3]) == gid:
assign_flag = False
break
if assign_flag:
opt = "-unit %s -assign %s %s -tno %d -user %s" % (unit, ctl_no, port_no, gid, auth_username)
ret, stdout, stderr = self.exec_hsnm("auchapuser", opt)
if ret:
if added_flag:
_ret, _stdout, _stderr = self.delete_chap_user(port)
if _ret:
msg = basic_lib.set_msg(303, user=auth_username)
LOG.warning(msg)
msg = basic_lib.output_err(600, cmd="auchapuser", ret=ret, out=stdout, err=stderr)
raise exception.HBSDCmdError(message=msg, ret=ret, err=stderr)
return added_flag
def _fill_groups(self, hgs, ports, target_iqn, target_alias, add_iqn):
for port in ports:
added_hostgroup = False
added_user = False
LOG.debug(
"Create target (hgs: %(hgs)s port: %(port)s "
"target_iqn: %(tiqn)s target_alias: %(alias)s "
"add_iqn: %(aiqn)s)",
{"hgs": hgs, "port": port, "tiqn": target_iqn, "alias": target_alias, "aiqn": add_iqn},
)
gid = self.common.command.get_gid_from_targetiqn(target_iqn, target_alias, port)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
gid = None
try:
gid = self._get_unused_gid_iscsi(port)
self.common.command.comm_add_hostgrp_iscsi(port, gid, target_alias, target_iqn)
added_hostgroup = True
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(312, resource="GID"))
continue
except Exception as ex:
LOG.warning(basic_lib.set_msg(309, port=port, alias=target_alias, reason=ex))
break
else:
LOG.debug("Completed to add target" "(port: %(port)s gid: %(gid)d)", {"port": port, "gid": gid})
break
if gid is None:
LOG.error(_LE("Failed to add target(port: %s)"), port)
continue
try:
if added_hostgroup:
if self.configuration.hitachi_auth_method:
added_user = self.common.command.set_chap_authention(port, gid)
self.common.command.comm_set_hostgrp_reportportal(port, target_alias)
self._add_initiator(hgs, port, gid, add_iqn)
except Exception as ex:
LOG.warning(basic_lib.set_msg(316, port=port, reason=ex))
if added_hostgroup:
if added_user:
self._delete_chap_user(port)
self._delete_iscsi_target(port, gid, target_alias)
def terminate_connection(self, volume, connector, **kwargs):
self.do_setup_status.wait()
ldev = self.common.get_ldev(volume)
if ldev is None:
LOG.warning(basic_lib.set_msg(302, volume_id=volume["id"]))
return
if "initiator" not in connector:
raise exception.HBSDError(message=basic_lib.output_err(650, resource="HBA"))
hostgroups = []
self._get_hostgroup_info_iscsi(hostgroups, connector["initiator"])
if not hostgroups:
raise exception.HBSDError(message=basic_lib.output_err(649))
self.common.add_volinfo(ldev, volume["id"])
with self.common.volume_info[ldev]["lock"], self.common.volume_info[ldev]["in_use"]:
self._terminate_connection(ldev, connector, hostgroups)
def copy_data(self, pvol, size, p_is_vvol, method):
type = "Normal"
is_vvol = method == "THIN"
svol = self._create_volume(size, is_vvol=is_vvol)
try:
if p_is_vvol:
self.copy_sync_data(pvol, svol, size)
else:
if is_vvol:
type = "V-VOL"
self.copy_async_data(pvol, svol, is_vvol)
except Exception:
with excutils.save_and_reraise_exception():
try:
self.delete_ldev(svol, is_vvol)
except Exception as ex:
LOG.warning(basic_lib.set_msg(313, ldev=svol, reason=ex))
return six.text_type(svol), type
def create_ldev(self, size, ldev_range, pool_id, is_vvol):
LOG.debug('create start (normal)')
for i in basic_lib.DEFAULT_TRY_RANGE:
LOG.debug('Try number: %(tries)s / %(max_tries)s',
{'tries': i + 1,
'max_tries': len(basic_lib.DEFAULT_TRY_RANGE)})
new_ldev = self._get_unused_volume_num(ldev_range)
try:
self._add_ldev(new_ldev, size, pool_id, is_vvol)
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(312, resource='LDEV'))
continue
else:
break
else:
msg = basic_lib.output_err(636)
raise exception.HBSDError(message=msg)
LOG.debug('create end (normal: %s)', new_ldev)
self.init_volinfo(self.volume_info, new_ldev)
return new_ldev
def copy_async_data(self, pvol, svol, is_vvol):
path_list = []
driver = self.generated_from
try:
with self.pair_flock:
self.delete_pair(pvol, all_split=False, is_vvol=is_vvol)
paired_info = self.command.get_paired_info(pvol)
if paired_info["pvol"] is None:
driver.pair_initialize_connection(pvol)
path_list.append(pvol)
driver.pair_initialize_connection(svol)
path_list.append(svol)
self.command.comm_create_pair(pvol, svol, is_vvol)
except Exception:
with excutils.save_and_reraise_exception():
for ldev in path_list:
try:
driver.pair_terminate_connection(ldev)
except Exception as ex:
LOG.warning(basic_lib.set_msg(310, ldev=ldev, reason=ex))
def copy_data(self, pvol, size, p_is_vvol, method):
type = 'Normal'
is_vvol = method == 'THIN'
svol = self._create_volume(size, is_vvol=is_vvol)
try:
if p_is_vvol:
self.copy_sync_data(pvol, svol, size)
else:
if is_vvol:
type = 'V-VOL'
self.copy_async_data(pvol, svol, is_vvol)
except Exception:
with excutils.save_and_reraise_exception():
try:
self.delete_ldev(svol, is_vvol)
except Exception as ex:
msg = basic_lib.set_msg(313,
ldev=svol,
reason=six.text_type(ex))
LOG.warning(msg)
return six.text_type(svol), type
def create_ldev(self, size, ldev_range, pool_id, is_vvol):
LOG.debug('create start (normal)')
for i in basic_lib.DEFAULT_TRY_RANGE:
LOG.debug('Try number: %(tries)s / %(max_tries)s' % {
'tries': i + 1,
'max_tries': len(basic_lib.DEFAULT_TRY_RANGE)
})
new_ldev = self._get_unused_volume_num(ldev_range)
try:
self._add_ldev(new_ldev, size, pool_id, is_vvol)
except exception.HBSDNotFound:
msg = basic_lib.set_msg(312, resource='LDEV')
LOG.warning(msg)
continue
else:
break
else:
msg = basic_lib.output_err(636)
raise exception.HBSDError(message=msg)
LOG.debug('create end (normal: %s)' % six.text_type(new_ldev))
self.init_volinfo(self.volume_info, new_ldev)
return new_ldev
def _initialize_connection(self, ldev, connector, src_hgs=None):
LOG.debug(
"Call _initialize_connection "
"(config_group: %(group)s ldev: %(ldev)d)", {
'group': self.configuration.config_group,
'ldev': ldev
})
if src_hgs is self.pair_hostgroups:
hostgroups = src_hgs
else:
hostgroups = []
security_ports = self._get_hostgroup_info(hostgroups,
connector['wwpns'],
login=True)
self.add_hostgroup_master(hostgroups, connector['wwpns'],
connector['ip'], security_ports)
if src_hgs is self.pair_hostgroups:
try:
self._add_lun(hostgroups, ldev)
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(311, ldev=ldev))
for i in range(self.max_hostgroups + 1):
self.pair_hostnum += 1
pair_hostgroups = []
try:
self.add_hostgroup_pair(pair_hostgroups)
self.pair_hostgroups.extend(pair_hostgroups)
except exception.HBSDNotFound:
if i >= self.max_hostgroups:
msg = basic_lib.output_err(648, resource='GID')
raise exception.HBSDError(message=msg)
else:
break
self.pair_initialize_connection(ldev)
else:
self._add_lun(hostgroups, ldev)
return hostgroups
def output_param_to_log(self, storage_protocol):
essential_inherited_param = ["volume_backend_name", "volume_driver"]
conf = self.configuration
LOG.info(basic_lib.set_msg(1, config_group=conf.config_group))
version = self.command.get_comm_version()
if conf.hitachi_unit_name:
prefix = "HSNM2 version"
else:
prefix = "RAID Manager version"
LOG.info(_LI("\t%(prefix)-35s : %(version)s"), {"prefix": prefix, "version": version})
for param in essential_inherited_param:
value = conf.safe_get(param)
LOG.info(_LI("\t%(param)-35s : %(value)s"), {"param": param, "value": value})
for opt in volume_opts:
if not opt.secret:
value = getattr(conf, opt.name)
LOG.info(_LI("\t%(name)-35s : %(value)s"), {"name": opt.name, "value": value})
if storage_protocol == "iSCSI":
value = getattr(conf, "hitachi_group_request")
LOG.info(_LI("\t%(request)-35s : %(value)s"), {"request": "hitachi_group_request", "value": value})
def copy_async_data(self, pvol, svol, is_vvol):
path_list = []
driver = self.generated_from
try:
with self.pair_flock:
self.delete_pair(pvol, all_split=False, is_vvol=is_vvol)
paired_info = self.command.get_paired_info(pvol)
if paired_info['pvol'] is None:
driver.pair_initialize_connection(pvol)
path_list.append(pvol)
driver.pair_initialize_connection(svol)
path_list.append(svol)
self.command.comm_create_pair(pvol, svol, is_vvol)
except Exception:
with excutils.save_and_reraise_exception():
for ldev in path_list:
try:
driver.pair_terminate_connection(ldev)
except Exception as ex:
msg = basic_lib.set_msg(
310, ldev=ldev, reason=six.text_type(ex))
LOG.warning(msg)
def terminate_connection(self, volume, connector, **kwargs):
self.do_setup_status.wait()
ldev = self.common.get_ldev(volume)
if ldev is None:
msg = basic_lib.set_msg(302, volume_id=volume['id'])
LOG.warning(msg)
return
if 'initiator' not in connector:
msg = basic_lib.output_err(650, resource='HBA')
raise exception.HBSDError(message=msg)
hostgroups = []
self._get_hostgroup_info_iscsi(hostgroups,
connector['initiator'])
if not hostgroups:
msg = basic_lib.output_err(649)
raise exception.HBSDError(message=msg)
self.common.add_volinfo(ldev, volume['id'])
with self.common.volume_info[ldev]['lock'],\
self.common.volume_info[ldev]['in_use']:
self._terminate_connection(ldev, connector, hostgroups)
def terminate_connection(self, volume, connector, **kwargs):
self.do_setup_status.wait()
ldev = self.common.get_ldev(volume)
if ldev is None:
msg = basic_lib.set_msg(302, volume_id=volume['id'])
LOG.warning(msg)
return
if 'initiator' not in connector:
msg = basic_lib.output_err(650, resource='HBA')
raise exception.HBSDError(message=msg)
hostgroups = []
self._get_hostgroup_info_iscsi(hostgroups,
connector['initiator'])
if not hostgroups:
msg = basic_lib.output_err(649)
raise exception.HBSDError(message=msg)
self.common.add_volinfo(ldev, volume['id'])
with self.common.volume_info[ldev]['lock'],\
self.common.volume_info[ldev]['in_use']:
self._terminate_connection(ldev, connector, hostgroups)
def _fill_group(self, hgs, port, host_grp_name, wwns):
added_hostgroup = False
LOG.debug('Create host group (hgs: %(hgs)s port: %(port)s '
'name: %(name)s wwns: %(wwns)s)'
% {'hgs': hgs, 'port': port,
'name': host_grp_name, 'wwns': wwns})
gid = self._get_hgname_gid(port, host_grp_name)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
try:
gid = self._get_unused_gid(port)
self._add_hostgroup(port, gid, host_grp_name)
added_hostgroup = True
except exception.HBSDNotFound:
gid = None
msg = basic_lib.set_msg(312, resource='GID')
LOG.warning(msg)
continue
else:
LOG.debug('Completed to add host target'
'(port: %(port)s gid: %(gid)d)'
% {'port': port, 'gid': gid})
break
else:
msg = basic_lib.output_err(641)
raise exception.HBSDError(message=msg)
try:
if wwns:
self._add_wwn(hgs, port, gid, wwns)
else:
hgs.append({'port': port, 'gid': gid, 'initiator_wwn': None,
'detected': True})
except Exception:
with excutils.save_and_reraise_exception():
if added_hostgroup:
self._delete_hostgroup(port, gid, host_grp_name)
def _fill_group(self, hgs, port, host_grp_name, wwns):
added_hostgroup = False
LOG.debug('Create host group (hgs: %(hgs)s port: %(port)s '
'name: %(name)s wwns: %(wwns)s)'
% {'hgs': hgs, 'port': port,
'name': host_grp_name, 'wwns': wwns})
gid = self._get_hgname_gid(port, host_grp_name)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
try:
gid = self._get_unused_gid(port)
self._add_hostgroup(port, gid, host_grp_name)
added_hostgroup = True
except exception.HBSDNotFound:
gid = None
msg = basic_lib.set_msg(312, resource='GID')
LOG.warning(msg)
continue
else:
LOG.debug('Completed to add host target'
'(port: %(port)s gid: %(gid)d)'
% {'port': port, 'gid': gid})
break
else:
msg = basic_lib.output_err(641)
raise exception.HBSDError(message=msg)
try:
if wwns:
self._add_wwn(hgs, port, gid, wwns)
else:
hgs.append({'port': port, 'gid': gid, 'initiator_wwn': None,
'detected': True})
except Exception:
with excutils.save_and_reraise_exception():
if added_hostgroup:
self._delete_hostgroup(port, gid, host_grp_name)
def _fill_group(self, hgs, port, host_grp_name, wwns):
added_hostgroup = False
LOG.debug(
"Create host group (hgs: %(hgs)s port: %(port)s "
"name: %(name)s wwns: %(wwns)s)" % {"hgs": hgs, "port": port, "name": host_grp_name, "wwns": wwns}
)
gid = self._get_hgname_gid(port, host_grp_name)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
try:
gid = self._get_unused_gid(port)
self._add_hostgroup(port, gid, host_grp_name)
added_hostgroup = True
except exception.HBSDNotFound:
gid = None
msg = basic_lib.set_msg(312, resource="GID")
LOG.warning(msg)
continue
else:
LOG.debug(
"Completed to add host target" "(port: %(port)s gid: %(gid)d)" % {"port": port, "gid": gid}
)
break
else:
msg = basic_lib.output_err(641)
raise exception.HBSDError(message=msg)
try:
if wwns:
self._add_wwn(hgs, port, gid, wwns)
else:
hgs.append({"port": port, "gid": gid, "initiator_wwn": None, "detected": True})
except Exception:
with excutils.save_and_reraise_exception():
if added_hostgroup:
self._delete_hostgroup(port, gid, host_grp_name)
def output_param_to_log(self, storage_protocol):
essential_inherited_param = ['volume_backend_name', 'volume_driver']
conf = self.configuration
msg = basic_lib.set_msg(1, config_group=conf.config_group)
LOG.info(msg)
version = self.command.get_comm_version()
if conf.hitachi_unit_name:
prefix = 'HSNM2 version'
else:
prefix = 'RAID Manager version'
LOG.info('\t%-35s%s' % (prefix + ': ', six.text_type(version)))
for param in essential_inherited_param:
value = conf.safe_get(param)
LOG.info('\t%-35s%s' % (param + ': ', six.text_type(value)))
for opt in volume_opts:
if not opt.secret:
value = getattr(conf, opt.name)
LOG.info('\t%-35s%s' % (opt.name + ': ', six.text_type(value)))
if storage_protocol == 'iSCSI':
value = getattr(conf, 'hitachi_group_request')
LOG.info('\t%-35s%s' %
('hitachi_group_request: ', six.text_type(value)))
def comm_add_lun(self, command, hostgroups, ldev, is_once=False):
unit = self.unit_name
tmp_hostgroups = hostgroups[:]
used_list = []
is_ok = False
hlu = None
old_hlu = None
for hostgroup in hostgroups:
port = hostgroup["port"]
gid = hostgroup["gid"]
hlu = self.add_used_hlun(command, port, gid, used_list, ldev)
# When 'hlu' or 'old_hlu' is 0, it should be true.
# So, it cannot remove 'is not None'.
if hlu is not None:
if old_hlu is not None and old_hlu != hlu:
msg = basic_lib.output_err(648, resource="LUN (HLUN)")
raise exception.HBSDError(message=msg)
is_ok = True
hostgroup["lun"] = hlu
tmp_hostgroups.remove(hostgroup)
old_hlu = hlu
else:
hlu = old_hlu
if not used_list:
hlu = 0
elif hlu is None:
for i in range(MAX_HLUN + 1):
if i not in used_list:
hlu = i
break
else:
raise exception.HBSDNotFound
ret = 0
stdout = None
stderr = None
invalid_hgs_str = None
for hostgroup in tmp_hostgroups:
port = hostgroup["port"]
gid = hostgroup["gid"]
ctl_no = port[0]
port_no = port[1]
if not hostgroup["detected"]:
if invalid_hgs_str:
invalid_hgs_str = "%s, %s:%d" % (invalid_hgs_str, port, gid)
else:
invalid_hgs_str = "%s:%d" % (port, gid)
continue
opt = "-unit %s -add %s %s %d %d %d" % (unit, ctl_no, port_no, gid, hlu, ldev)
ret, stdout, stderr = self.exec_hsnm(command, opt)
if ret == 0:
is_ok = True
hostgroup["lun"] = hlu
if is_once:
break
else:
msg = basic_lib.set_msg(314, ldev=ldev, lun=hlu, port=port, id=gid)
LOG.warning(msg)
if not is_ok:
if stderr:
msg = basic_lib.output_err(600, cmd=command, ret=ret, out=stdout, err=stderr)
raise exception.HBSDCmdError(message=msg, ret=ret, err=stderr)
else:
msg = basic_lib.output_err(659, gid=invalid_hgs_str)
raise exception.HBSDError(message=msg)
def _delete_lun(self, hostgroups, ldev):
try:
self.common.command.comm_delete_lun(hostgroups, ldev)
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(301, ldev=ldev))
def output_backend_available_once(self):
if self.output_first:
self.output_first = False
msg = basic_lib.set_msg(
3, config_group=self.configuration.config_group)
LOG.warning(msg)
def _fill_groups(self, hgs, ports, target_iqn, target_alias, add_iqn):
for port in ports:
added_hostgroup = False
added_user = False
LOG.debug(
'Create target (hgs: %(hgs)s port: %(port)s '
'target_iqn: %(tiqn)s target_alias: %(alias)s '
'add_iqn: %(aiqn)s)' % {
'hgs': hgs,
'port': port,
'tiqn': target_iqn,
'alias': target_alias,
'aiqn': add_iqn
})
gid = self.common.command.get_gid_from_targetiqn(
target_iqn, target_alias, port)
if gid is None:
for retry_cnt in basic_lib.DEFAULT_TRY_RANGE:
gid = None
try:
gid = self._get_unused_gid_iscsi(port)
self.common.command.comm_add_hostgrp_iscsi(
port, gid, target_alias, target_iqn)
added_hostgroup = True
except exception.HBSDNotFound:
msg = basic_lib.set_msg(312, resource='GID')
LOG.warning(msg)
continue
except Exception as ex:
msg = basic_lib.set_msg(309,
port=port,
alias=target_alias,
reason=six.text_type(ex))
LOG.warning(msg)
break
else:
LOG.debug('Completed to add target'
'(port: %(port)s gid: %(gid)d)' % {
'port': port,
'gid': gid
})
break
if gid is None:
LOG.error(_('Failed to add target(port: %s)') % port)
continue
try:
if added_hostgroup:
if self.configuration.hitachi_auth_method:
added_user = self.common.command.set_chap_authention(
port, gid)
self.common.command.comm_set_hostgrp_reportportal(
port, target_alias)
self._add_initiator(hgs, port, gid, add_iqn)
except Exception as ex:
msg = basic_lib.set_msg(316,
port=port,
reason=six.text_type(ex))
LOG.warning(msg)
if added_hostgroup:
if added_user:
self._delete_chap_user(port)
self._delete_iscsi_target(port, gid, target_alias)
def _delete_chap_user(self, port):
ret, _stdout, _stderr = self.common.command.delete_chap_user(port)
if ret:
LOG.warning(basic_lib.set_msg(303, user=self.configuration.hitachi_auth_user))
def _delete_chap_user(self, port):
ret, _stdout, _stderr = self.common.command.delete_chap_user(port)
if ret:
LOG.warning(
basic_lib.set_msg(303,
user=self.configuration.hitachi_auth_user))
def _delete_lun_iscsi(self, hostgroups, ldev):
try:
self.common.command.comm_delete_lun_iscsi(hostgroups, ldev)
except exception.HBSDNotFound:
LOG.warning(basic_lib.set_msg(301, ldev=ldev))
def output_backend_available_once(self):
if self.output_first:
self.output_first = False
LOG.warning(
basic_lib.set_msg(
3, config_group=self.configuration.config_group))
def comm_add_lun(self, command, hostgroups, ldev, is_once=False):
unit = self.unit_name
tmp_hostgroups = hostgroups[:]
used_list = []
is_ok = False
hlu = None
old_hlu = None
for hostgroup in hostgroups:
port = hostgroup['port']
gid = hostgroup['gid']
hlu = self.add_used_hlun(command, port, gid, used_list, ldev)
# When 'hlu' or 'old_hlu' is 0, it should be true.
# So, it cannot remove 'is not None'.
if hlu is not None:
if old_hlu is not None and old_hlu != hlu:
msg = basic_lib.output_err(648, resource='LUN (HLUN)')
raise exception.HBSDError(message=msg)
is_ok = True
hostgroup['lun'] = hlu
tmp_hostgroups.remove(hostgroup)
old_hlu = hlu
else:
hlu = old_hlu
if not used_list:
hlu = 0
elif hlu is None:
for i in range(MAX_HLUN + 1):
if i not in used_list:
hlu = i
break
else:
raise exception.HBSDNotFound
ret = 0
stdout = None
stderr = None
invalid_hgs_str = None
for hostgroup in tmp_hostgroups:
port = hostgroup['port']
gid = hostgroup['gid']
ctl_no = port[0]
port_no = port[1]
if not hostgroup['detected']:
if invalid_hgs_str:
invalid_hgs_str = '%s, %s:%d' % (invalid_hgs_str, port,
gid)
else:
invalid_hgs_str = '%s:%d' % (port, gid)
continue
opt = '-unit %s -add %s %s %d %d %d' % (unit, ctl_no, port_no, gid,
hlu, ldev)
ret, stdout, stderr = self.exec_hsnm(command, opt)
if ret == 0:
is_ok = True
hostgroup['lun'] = hlu
if is_once:
break
else:
msg = basic_lib.set_msg(314,
ldev=ldev,
lun=hlu,
port=port,
id=gid)
LOG.warning(msg)
if not is_ok:
if stderr:
msg = basic_lib.output_err(600,
cmd=command,
ret=ret,
out=stdout,
err=stderr)
raise exception.HBSDCmdError(message=msg, ret=ret, err=stderr)
else:
msg = basic_lib.output_err(659, gid=invalid_hgs_str)
raise exception.HBSDError(message=msg)