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)