def create_lun(self,
lun_name=None,
size_gb=1,
lun_id=None,
provision=None,
tier=None,
ignore_thresholds=None):
pool = {}
if self._pool_id is not None:
pool['pool_id'] = self._pool_id
else:
pool['pool_name'] = self._get_name()
ret = self._cli.create_pool_lun(
lun_name=lun_name,
lun_id=lun_id,
size_gb=size_gb,
provision=provision,
tier=tier,
ignore_thresholds=ignore_thresholds,
poll=self.poll,
**pool)
ex.raise_if_err(ret, 'error creating lun.',
default=ex.VNXCreateLunError)
lun_clz = storops.vnx.resource.lun.VNXLun
ret = lun_clz(lun_id, lun_name, self._cli)
if provision == VNXProvisionEnum.COMPRESSED:
ret.enable_compression()
ret.update()
return ret
def rename(self, new_name):
if new_name is not None and new_name != self._name:
ret = self._cli.modify_storage_pool(new_name=new_name,
poll=self.poll,
**self._get_name_or_id())
ex.raise_if_err(ret, default=ex.VNXModifyPoolError)
self._name = new_name
def disable_compression(self, ignore_thresholds=None):
lun_id = self.get_id(self)
out = self._cli.disable_compression(lun_id, ignore_thresholds,
poll=self.poll)
ex.raise_if_err(
out, 'failed to disable compression on {}.'.format(lun_id),
default=ex.VNXCompressionError)
def enable_compression(self, rate=None, ignore_thresholds=None):
lun_id = self.get_id(self)
out = self._cli.enable_compression(
lun_id=lun_id, rate=rate, ignore_thresholds=ignore_thresholds,
poll=self.poll)
msg = 'failed to enable compression on {}.'.format(lun_id)
ex.raise_if_err(out, msg, ex.VNXCompressionError)
def delete(self, force=False):
if force:
if self.secondary_image:
self.remove_image()
out = self._cli.delete_mirror_view(self._get_name())
raise_if_err(out, default=VNXMirrorException)
def _cg_member_op(self, op, lun_list):
clz = storops.vnx.resource.lun.VNXLun
id_list = clz.get_id_list(*lun_list)
name = self._get_name()
out = op(name, *id_list, poll=self.poll)
ex.raise_if_err(out, 'error change member of "{}".'.format(name),
default=ex.VNXConsistencyGroupError)
def tier(self, new_tier):
new_tier = VNXTieringEnum.parse(new_tier)
out = self._cli.modify_lun(lun_id=self._lun_id,
lun_name=self._name,
new_tier=new_tier,
poll=self.poll)
msg = 'error change lun tier.'
ex.raise_if_err(out, msg, default=ex.VNXModifyLunError)
def create(cli, name, disks, raid_type=None, ):
if isinstance(disks, VNXDiskList):
disks = sorted(disks.index)
if not disks:
raise VNXNotEnoughDiskAvailableError()
ret = cli.create_pool(name, disks, raid_type)
ex.raise_if_err(ret, default=ex.VNXCreatePoolError)
return VNXPool(name=name, cli=cli)
def promote_image(self, image_id=None):
if image_id is None:
image_id = self.secondary_image_id
image_id = self._get_image_id(image_id)
out = self._cli.mirror_view_promote_image(self._get_name(), image_id,
poll=self.poll)
raise_if_err(out, default=VNXMirrorException)
def delete_ip(self, vport_id=None):
if self.type != VNXPortType.ISCSI:
raise TypeError('delete IP only works for iSCSI ports.')
if vport_id is None:
vport_id = self.vport_id
out = self._cli.delete_iscsi_ip(self.sp, self.port_id, vport_id)
raise_if_err(out, default=VNXPortError)
def modify(self, new_name=None, desc=None,
auto_delete=None, allow_rw=None):
name = self._get_name()
out = self._cli.modify_snap(name, new_name, desc, auto_delete,
allow_rw, poll=self.poll)
ex.raise_if_err(out, 'failed to modify snap {}.'.format(name),
default=ex.VNXModifySnapError)
if new_name is not None:
self._name = new_name
def rename(self, new_name):
if new_name is not None and self._name != new_name:
out = self._cli.modify_lun(lun_id=self._lun_id,
lun_name=self._name,
new_name=new_name,
poll=self.poll)
ex.raise_if_err(out, 'failed to change lun name.',
default=ex.VNXModifyLunError)
self._name = new_name
def create_mount_point(self, _id=None, name=None):
lun_id = self.get_id(self)
out = self._cli.create_mount_point(
primary_lun_id=lun_id,
mount_point_name=name,
mount_point_id=_id,
poll=self.poll)
ex.raise_if_err(out, default=ex.VNXCreateMpError)
return VNXLun(lun_id=_id, name=name, cli=self._cli)
def copy(self, new_name,
ignore_migration_check=False,
ignore_dedup_check=False):
name = self._get_name()
out = self._cli.copy_snap(name, new_name,
ignore_migration_check,
ignore_dedup_check, poll=self.poll)
ex.raise_if_err(out, 'failed to copy snap {}.'.format(name),
default=ex.VNXSnapError)
return VNXSnap(name=new_name, cli=self._cli)
def detach_alu(self, lun):
alu = storops.vnx.resource.lun.VNXLun.get_id(lun)
hlu = self.get_hlu(lun)
if hlu is None:
raise ex.VNXDetachAluNotFoundError(
'specified lun {} is not attached.'.format(alu))
out = self._cli.sg_delete_hlu(self._get_name(), hlu, poll=self.poll)
msg = 'failed to detach hlu {}/alu {}.'.format(hlu, alu)
ex.raise_if_err(out, msg, default=ex.VNXStorageGroupError, )
self._delete_alu(alu)
def add_image(self, sp_ip, lun_id,
recovery_policy=VNXMirrorViewRecoveryPolicy.AUTO,
sync_rate=VNXMirrorViewSyncRate.HIGH):
if hasattr(sp_ip, 'spa_ip'):
sp_ip = sp_ip.spa_ip
lun_clz = storops.vnx.resource.lun.VNXLun
lun_id = lun_clz.get_id(lun_id)
out = self._cli.add_mirror_view_image(self._get_name(), sp_ip, lun_id,
recovery_policy, sync_rate,
poll=self.poll)
raise_if_err(out, default=VNXMirrorException)
def config_ip(self, ip, mask, gateway, vport_id=None, vlan_id=None):
if self.type != VNXPortType.ISCSI:
raise TypeError('configure IP only works for iSCSI ports.')
if vport_id is None:
vport_id = self.vport_id
out = self._cli.config_iscsi_ip(
self.sp, self.port_id, ip, mask, gateway, vport_id=vport_id,
vlan_id=vlan_id)
raise_if_err(out, default=VNXPortError)
if vport_id is None:
vport_id = 0
return VNXConnectionPort(self.sp, self.port_id, vport_id, self._cli)
def ping_node(self, address, packet_size=None, count=None, timeout=None,
delay=None):
out = self._cli.ping_node(address=address,
sp=self.sp,
port_id=self.port_id,
vport_id=self.virtual_port_id,
packet_size=packet_size,
count=count,
timeout=timeout,
delay=delay)
try:
raise_if_err(out, default=VNXPingNodeError)
except VNXPingNodeSuccess:
# ping success, pass
pass
def _do(alu_id):
hlu = self._get_hlu_to_add(alu_id)
out = self._cli.sg_add_hlu(self._get_name(), hlu, alu_id,
poll=self.poll)
try:
ex.raise_if_err(out, default=ex.VNXAttachAluError)
except ex.VNXAluAlreadyAttachedError:
# alu no in the alu-hlu map cache but attach failed with
# already attached, that means the cache is out dated
self.update()
raise
except ex.VNXAttachAluError:
# other attach error, remove hlu id from the cache
self._delete_alu(alu_id)
raise
return hlu
def set_path(self, port, hba_uid, host_name, host_ip=None):
if hasattr(port, 'sp'):
sp = port.sp
else:
raise ValueError('sp is not available from {}.'.format(port))
if hasattr(port, 'port_id'):
port_id = port.port_id
else:
raise ValueError('port id is not available from {}.'.format(port))
vport_id = None
if hasattr(port, 'virtual_port_id'):
# FCoE do not need vport_id
if hasattr(port, 'type'):
port_type = port.type
if port_type == VNXPortType.ISCSI:
vport_id = port.virtual_port_id
out = self._cli.set_path(self._get_name(), hba_uid, sp, port_id,
host_ip, host_name, vport_id=vport_id)
ex.raise_if_err(out)
def delete(self, delete_snapshots=False, force_detach=False,
detach_from_sg=False, detach_from_cg=False, force=False):
if force:
delete_snapshots = True
force_detach = True
detach_from_sg = True
detach_from_cg = True
self.clear_smp(force)
if detach_from_sg:
self.detach_from_sg()
if detach_from_cg:
self.detach_from_cg()
name = self._get_name()
out = self._cli.delete_pool_lun(self._lun_id,
name,
delete_snapshots=delete_snapshots,
force_detach=force_detach,
poll=self.poll)
ex.raise_if_err(out, 'failed to remove lun {}'.format(name),
default=ex.VNXDeleteLunError)
def promote_group(self, promote_type=None):
out = self._cli.promote_mirror_group_async(self._get_name(),
promote_type=promote_type,
poll=self.poll)
raise_if_err(out, default=VNXMirrorException)
def delete(self, force=False):
out = self._cli.delete_mirror_group_async(self._get_name(),
force=force)
raise_if_err(out, default=VNXMirrorException)
def create(cls, cli, name, src_lun, use_write_intent_log=True):
lun_clz = storops.vnx.resource.lun.VNXLun
lun_id = lun_clz.get_id(src_lun)
out = cli.create_mirror_view(name, lun_id, use_write_intent_log)
raise_if_err(out, default=VNXMirrorException)
return VNXMirrorView(name, cli=cli)
def f():
output = "Cannot find the consistency group."
raise_if_err(output)
def delete(self):
name = self._get_name()
out = self._cli.delete_snap(name, poll=self.poll)
ex.raise_if_err(out, default=ex.VNXDeleteSnapError)
def f():
out = ('Could not retrieve the specified (pool lun). '
'The (pool lun) may not exist')
raise_if_err(out)
def f():
out = ("A network error occurred while "
"trying to connect: '10.244.211.33'.\n"
"Message : select: The connect timed out.")
raise_if_err(out)
def f():
out = ('Error returned from the target: 10.244.211.32\n'
'CLI commands are not supported by the '
'target storage system.')
raise_if_err(out)
def f():
raise_if_err(error)
def f():
output = ("Cannot unbind LUN because "
"it's contained in a Storage Group.")
raise_if_err(output)
def f():
output = """Could not retrieve the specified (pool lun).
The (pool lun) may not exist."""
raise_if_err(output)
def f():
output = "The specified snapshot does not exist."
raise_if_err(output)
def delete(self, disconnect_host=False):
if disconnect_host:
for hba in self.hba_sp_pairs:
self.disconnect_host(hba.host_name)
out = self._cli.delete_sg(self._get_name(), poll=self.poll)
ex.raise_if_err(out, default=ex.VNXDeleteStorageGroupError)
def delete(self):
name = self._get_name()
out = self._cli.delete_cg(name, poll=self.poll)
ex.raise_if_err(out, 'error remove cg "{}".'.format(name),
default=ex.VNXConsistencyGroupError)
def delete(self, force=False):
if force:
self.clear()
ret = self._cli.delete_pool(poll=self.poll, **self._get_name_or_id())
ex.raise_if_err(ret, default=ex.VNXDeletePoolError)
def create(cli, raid_group_id, disks, raid_type=None):
ret = cli.create_rg(disks, raid_group_id, raid_type)
ex.raise_if_err(ret, default=ex.VNXCreateRaidGroupError)
return VNXRaidGroup(raid_group_id, cli)
def delete(self):
name = self._get_name()
out = self._cli.delete_cg(name, poll=self.poll)
ex.raise_if_err(out,
'error remove cg "{}".'.format(name),
default=ex.VNXConsistencyGroupError)
def delete(self):
ret = self._cli.delete_rg(self._get_raid_group_id(), poll=self.poll)
ex.raise_if_err(ret, default=ex.VNXDeleteRaidGroupError)
def f():
msg = ("SP A: Expansion LUN size must be "
"greater than current LUN size. (0x712d8e04)")
raise_if_err(msg)
def _update_dedup_state(self, tgt_state):
out = self._cli.modify_lun(lun_id=self._lun_id,
lun_name=self._name,
dedup=tgt_state, poll=self.poll)
ex.raise_if_err(out, default=ex.VNXDedupError)
def test_raise_if_err_normal(self):
raise_if_err('')
def create(cls, cli, name, members=None, auto_delete=None):
out = cli.create_cg(name, members, auto_delete)
ex.raise_if_err(out,
'error creating cg {}.'.format(name),
default=VNXCreateConsistencyGroupError)
return VNXConsistencyGroup(name=name, cli=cli)
def sync_group(self):
out = self._cli.sync_mirror_group_async(self._get_name(),
poll=self.poll)
raise_if_err(out, default=VNXMirrorException)
def create(cls, cli, name, src_lun):
lun_clz = storops.vnx.resource.lun.VNXLun
lun_id = lun_clz.get_id(src_lun)
out = cli.create_mirror_view(name, lun_id)
raise_if_err(out, default=VNXMirrorException)
return VNXMirrorView(name, cli=cli)
def _do_modify():
out = self._cli.modify_policy(self._get_name(), new_name,
new_names, time_limit, fail_action,
eval_window)
ex.raise_if_err(out, default=ex.VNXIOPolicyError)
def delete(self):
out = self._cli.delete_policy(self._get_name())
ex.raise_if_err(out)
return VNXIOPolicy.get(name=self._get_name(), cli=self._cli)
def run_policy(self):
out = self._cli.run_policy(self._get_name())
ex.raise_if_err(out, default=ex.VNXIOPolicyError)
def disconnect_host(self, host):
out = self._cli.sg_disconnect_host(self._get_name(), host,
poll=self.poll)
msg = 'failed to disconnect host {}.'.format(host)
ex.raise_if_err(out, msg, default=ex.VNXStorageGroupError)
def stop_policy(cli):
out = cli.stop_policy()
ex.raise_if_err(out, default=ex.VNXIOPolicyError)
def create(cls, name, cli):
out = cli.create_sg(name)
msg = 'failed to create storage group "{}".'.format(name)
ex.raise_if_err(out, msg, default=ex.VNXCreateStorageGroupError)
return VNXStorageGroup(name, cli)
def set_name(self, new_name):
out = self._cli.set_array_name(new_name)
raise_if_err(out, default=VNXSetArrayNameError)
def create(cls, cli, name, members=None, auto_delete=None):
out = cli.create_cg(name, members, auto_delete)
ex.raise_if_err(out, 'error creating cg {}.'.format(name),
default=VNXCreateConsistencyGroupError)
return VNXConsistencyGroup(name=name, cli=cli)
def cancel_migrate(self):
src_id = self.get_id(self)
out = self._cli.cancel_migrate_lun(src_id, poll=self.poll)
ex.raise_if_err(out, 'migrate lun {} error.'.format(src_id),
default=ex.VNXMigrationError)
def delete_hba(cls, cli, hba_uid):
out = cli.delete_hba(hba_uid)
raise_if_err(out)
def f():
raise_if_err('error msg', msg="error received")
def _do_modify():
out = self._cli.modify_ioclass(self._get_name(), new_name, iotype,
lun_ids, smp_names, ctrlmethod,
minsize, maxsize)
ex.raise_if_err(out, default=ex.VNXIOClassError)
def delete(self):
out = self._cli.delete_ioclass(self._get_name())
ex.raise_if_err(out, default=ex.VNXIOClassError)
return VNXIOClass.get(name=self._get_name(), cli=self._cli)
def delete_hba(cls, cli, hba_uid):
out = cli.delete_hba(hba_uid)
raise_if_err(out)
def remove_mirror(self, mirror):
mirror_name = mirror._get_name()
out = self._cli.remove_from_mirror_group_async(self._get_name(),
mirror_name,
poll=self.poll)
raise_if_err(out, default=VNXMirrorException)
