def create(cls,
cli,
name,
pool,
size,
sp=None,
host_access=None,
is_thin=None,
description=None,
io_limit_policy=None,
is_repl_dst=None,
tiering_policy=None,
snap_schedule=None,
is_compression=None):
pool_clz = storops.unity.resource.pool.UnityPool
pool = pool_clz.get(cli, pool)
req_body = cls._compose_lun_parameter(cli,
name=name,
pool=pool,
size=size,
sp=sp,
is_thin=is_thin,
host_access=host_access,
description=description,
io_limit_policy=io_limit_policy,
is_repl_dst=is_repl_dst,
tiering_policy=tiering_policy,
snap_schedule=snap_schedule,
is_compression=is_compression)
resp = cli.type_action(UnityStorageResource().resource_class,
'createLun', **req_body)
resp.raise_if_err()
sr = UnityStorageResource(_id=resp.resource_id, cli=cli)
return sr.luns[0]
def create(cls,
cli,
name,
pool,
size,
sp=None,
host_access=None,
is_thin=None,
description=None,
io_limit_policy=None,
is_repl_dst=None,
tiering_policy=None,
snap_schedule=None,
is_snap_schedule_paused=None,
skip_sync_to_remote_system=None,
is_compression=None,
create_vmfs=False,
major_version=None,
block_size=None,
is_advanced_dedup_enabled=None):
pool_clz = storops.unity.resource.pool.UnityPool
pool = pool_clz.get(cli, pool)
req_body = cls._compose_lun_parameter(
cli,
name=name,
pool=pool,
size=size,
sp=sp,
is_thin=is_thin,
host_access=host_access,
description=description,
io_limit_policy=io_limit_policy,
is_repl_dst=is_repl_dst,
tiering_policy=tiering_policy,
snap_schedule=snap_schedule,
is_snap_schedule_paused=is_snap_schedule_paused,
skip_sync_to_remote_system=skip_sync_to_remote_system,
is_compression=is_compression,
major_version=major_version,
block_size=block_size,
is_advanced_dedup_enabled=is_advanced_dedup_enabled)
create_method = 'createVmwareLun' if create_vmfs else 'createLun'
resp = cli.type_action(UnityStorageResource().resource_class,
create_method, **req_body)
resp.raise_if_err()
sr = UnityStorageResource(_id=resp.resource_id, cli=cli)
return sr.luns[0]
def test_get_properties(self):
sr = UnityStorageResource(_id='res_27', cli=t_rest())
assert_that(sr.id, equal_to('res_27'))
assert_that(sr.type, equal_to(StorageResourceTypeEnum.FILE_SYSTEM))
assert_that(sr.replication_type, equal_to(ReplicationTypeEnum.NONE))
assert_that(sr.thin_status, equal_to(ThinStatusEnum.TRUE))
assert_that(sr.relocation_policy,
equal_to(TieringPolicyEnum.AUTOTIER_HIGH))
assert_that(sr.health, instance_of(UnityHealth))
assert_that(sr.name, equal_to('fs3'))
assert_that(sr.description, equal_to(''))
assert_that(sr.is_replication_destination, equal_to(False))
assert_that(sr.size_total, equal_to(3221225472))
assert_that(sr.size_used, equal_to(1620303872))
assert_that(sr.size_allocated, equal_to(3221225472))
assert_that(sr.per_tier_size_used, equal_to([6442450944, 0, 0]))
assert_that(sr.metadata_size, equal_to(3489660928))
assert_that(sr.metadata_size_allocated, equal_to(3221225472))
assert_that(sr.snaps_size_total, equal_to(0))
assert_that(sr.snaps_size_allocated, equal_to(0))
assert_that(sr.snap_count, equal_to(0))
assert_that(sr.pools, instance_of(UnityPoolList))
assert_that(sr.filesystem, instance_of(UnityFileSystem))
assert_that(sr.advanced_dedup_status,
equal_to(DedupStatusEnum.DISABLED))
assert_that(sr.data_reduction_status,
equal_to(DataReductionStatusEnum.DISABLED))
assert_that(sr.data_reduction_size_saved, equal_to(0))
assert_that(sr.data_reduction_percent, equal_to(0))
assert_that(sr.data_reduction_ratio, equal_to(1.0))
def modify(self,
name=None,
size=None,
host_access=None,
description=None,
sp=None,
io_limit_policy=None,
is_repl_dst=None,
tiering_policy=None,
snap_schedule=None,
is_compression=None):
req_body = self._compose_lun_parameter(self._cli,
name=name,
pool=None,
size=size,
sp=sp,
host_access=host_access,
description=description,
io_limit_policy=io_limit_policy,
is_repl_dst=is_repl_dst,
tiering_policy=tiering_policy,
snap_schedule=snap_schedule,
is_compression=is_compression)
resp = self._cli.action(UnityStorageResource().resource_class,
self.get_id(), 'modifyLun', **req_body)
resp.raise_if_err()
return resp
def create(cls,
cli,
pool,
nas_server,
name,
size,
proto=None,
is_thin=None,
tiering_policy=None,
user_cap=False,
is_compression=None,
access_policy=None,
locking_policy=None,
description=None):
pool_clz = storops.unity.resource.pool.UnityPool
nas_server_clz = storops.unity.resource.nas_server.UnityNasServer
if proto is None:
proto = FSSupportedProtocolEnum.NFS
pool = pool_clz.get(cli, pool)
nas_server = nas_server_clz.get(cli, nas_server)
size = supplement_filesystem(size, user_cap)
fs_param = cls.prepare_fs_parameters(pool=pool,
nas_server=nas_server,
supported_protocols=proto,
is_thin_enabled=is_thin,
size=size,
tiering_policy=tiering_policy,
is_compression=is_compression,
access_policy=access_policy,
locking_policy=locking_policy)
req_body = cli.make_body(allow_empty=True,
name=name,
description=description,
fsParameters=fs_param)
resp = cli.type_action(UnityStorageResource().resource_class,
'createFilesystem', **req_body)
resp.raise_if_err()
sr = UnityStorageResource(_id=resp.resource_id, cli=cli)
return sr.filesystem
def create(cls,
cli,
pool,
nas_server,
name,
size,
proto=None,
is_thin=None,
tiering_policy=None,
user_cap=False):
pool_clz = storops.unity.resource.pool.UnityPool
nas_server_clz = storops.unity.resource.nas_server.UnityNasServer
if proto is None:
proto = FSSupportedProtocolEnum.NFS
pool = pool_clz.get(cli, pool)
nas_server = nas_server_clz.get(cli, nas_server)
FSSupportedProtocolEnum.verify(proto)
TieringPolicyEnum.verify(tiering_policy)
size = supplement_filesystem(size, user_cap)
req_body = {
'name': name,
'fsParameters': {
'pool': pool,
'nasServer': nas_server,
'supportedProtocols': proto,
'isThinEnabled': is_thin,
'size': size,
'fastVPParameters': {
'tieringPolicy': tiering_policy
}
},
}
resp = cli.type_action(UnityStorageResource().resource_class,
'createFilesystem', **req_body)
resp.raise_if_err()
sr = UnityStorageResource(_id=resp.resource_id, cli=cli)
return sr.filesystem
def thin_clone(cli,
lun_or_snap,
name,
io_limit_policy=None,
description=None):
from storops.unity.resource.lun import UnityLun
from storops.unity.resource.storage_resource import \
UnityStorageResource
snap_to_tc = None # None means to create a temp snap for thin clone
if isinstance(lun_or_snap, UnityLun):
tc_node = lun_or_snap
else:
# `lun_or_snap` is an UnitySnap, use it for thin clone directly.
tc_node = lun_or_snap.lun
snap_to_tc = lun_or_snap
_id = lun_or_snap.get_id()
if _id in TCHelper._tc_cache:
tc_node = TCHelper._tc_cache[_id]
snap_to_tc = None
log.debug(
'Found %(id)s in TCHelper cache. Use it: %(cache)s as '
'the base to thin clone.', {
'id': _id,
'cache': tc_node
})
if snap_to_tc is None:
snap_to_tc = tc_node.create_snap(name='tmp-{}'.format(name),
is_auto_delete=False)
log.debug('Temp snap used for thin clone is created: %s.',
snap_to_tc.get_id())
req_body = TCHelper._compose_thin_clone(
cli,
name=name,
snap=snap_to_tc,
description=description,
io_limit_policy=io_limit_policy)
resp = cli.action(UnityStorageResource().resource_class,
tc_node.get_id(), 'createLunThinClone', **req_body)
if snap_to_tc != lun_or_snap:
# Delete the temp snap
snap_to_tc.delete()
resp.raise_if_err()
return UnityLun(cli=cli, _id=resp.resource_id)
def modify(self, name=None, description=None, is_repl_dst=None,
snap_schedule=None, is_snap_schedule_paused=None,
skip_sync_to_remote_system=None, tiering_policy=None,
is_compression=None, hosts=None,
lun_add=None, lun_remove=None, host_add=None,
host_remove=None, lun_modify=None):
req_body = self._compose_cg_parameters(
self._cli, name, description,
is_repl_dst, snap_schedule,
is_snap_schedule_paused, skip_sync_to_remote_system,
tiering_policy, is_compression, hosts,
lun_add, lun_remove, host_add, host_remove, lun_modify)
resp = self._cli.action(UnityStorageResource().resource_class,
self.get_id(), 'modifyConsistencyGroup',
**req_body)
resp.raise_if_err()
return resp
def modify(self,
name=None,
size=None,
host_access=None,
description=None,
sp=None,
io_limit_policy=None,
is_repl_dst=None,
tiering_policy=None,
snap_schedule=None,
is_compression=None):
if self.is_cg_member:
if is_repl_dst is not None or snap_schedule is not None:
log.warning('LUN in CG not support to modify `is_repl_dst` and'
' `snap_schedule`.')
return self.cg.modify_lun(self,
name=name,
size=size,
host_access=host_access,
description=description,
sp=sp,
io_limit_policy=io_limit_policy,
tiering_policy=tiering_policy,
is_compression=is_compression)
else:
req_body = self._compose_lun_parameter(
self._cli,
name=name,
pool=None,
size=size,
sp=sp,
host_access=host_access,
description=description,
io_limit_policy=io_limit_policy,
is_repl_dst=is_repl_dst,
tiering_policy=tiering_policy,
snap_schedule=snap_schedule,
is_compression=is_compression)
resp = self._cli.action(UnityStorageResource().resource_class,
self.get_id(), 'modifyLun', **req_body)
resp.raise_if_err()
return resp
def create(cls,
cli,
storage_resource,
name=None,
description=None,
is_auto_delete=None,
retention_duration=None,
is_read_only=None,
fs_access_type=None):
FilesystemSnapAccessTypeEnum.verify(fs_access_type)
sr = UnityStorageResource.get(cli, storage_resource)
resp = cli.post(cls().resource_class,
storageResource=sr,
name=name,
description=description,
isAutoDelete=is_auto_delete,
retentionDuration=retention_duration,
isReadOnly=is_read_only,
filesystemAccessType=fs_access_type)
resp.raise_if_err()
return cls(_id=resp.resource_id, cli=cli)
def create(cls,
cli,
name,
description=None,
is_repl_dst=None,
snap_schedule=None,
tiering_policy=None,
is_compression=None,
hosts=None,
lun_add=None):
req_body = cls._compose_cg_parameters(cli, name, description,
is_repl_dst, snap_schedule,
tiering_policy, is_compression,
hosts, lun_add)
resp = cli.type_action(UnityStorageResource().resource_class,
'createConsistencyGroup', **req_body)
try:
resp.raise_if_err()
except UnityStorageResourceNameInUseError:
raise UnityConsistencyGroupNameInUseError()
except: # noqa
raise
return UnityConsistencyGroup(_id=resp.resource_id, cli=cli)
def modify(self,
name=None,
size=None,
host_access=None,
description=None,
sp=None,
io_limit_policy=None,
is_repl_dst=None,
tiering_policy=None,
snap_schedule=None,
is_snap_schedule_paused=None,
skip_sync_to_remote_system=None,
is_compression=None,
major_version=None,
block_size=None,
is_advanced_dedup_enabled=None):
if self.is_cg_member:
if any(each is not None for each in [
is_repl_dst, snap_schedule, is_snap_schedule_paused,
skip_sync_to_remote_system
]):
log.warning('LUN in CG not support to modify `is_repl_dst`'
' `snap_schedule`, `is_snap_schedule_paused` and'
' `skip_sync_to_remote_system`.')
return self.cg.modify_lun(self,
name=name,
size=size,
host_access=host_access,
description=description,
sp=sp,
io_limit_policy=io_limit_policy,
tiering_policy=tiering_policy,
is_compression=is_compression)
else:
req_body = self._compose_lun_parameter(
self._cli,
name=name,
pool=None,
size=size,
sp=sp,
host_access=host_access,
description=description,
io_limit_policy=io_limit_policy,
is_repl_dst=is_repl_dst,
tiering_policy=tiering_policy,
snap_schedule=snap_schedule,
is_snap_schedule_paused=is_snap_schedule_paused,
skip_sync_to_remote_system=skip_sync_to_remote_system,
is_compression=is_compression,
major_version=major_version,
block_size=block_size,
is_advanced_dedup_enabled=is_advanced_dedup_enabled)
if self.is_vmware_vmfs:
resp = self._cli.action(UnityStorageResource().resource_class,
self.storage_resource.get_id(),
'modifyVmwareLun', **req_body)
else:
resp = self._cli.action(UnityStorageResource().resource_class,
self.get_id(), 'modifyLun', **req_body)
resp.raise_if_err()
return resp
