def test_user_cap_no(self):
size_byte = bitmath.GiB(1).to_Byte().value
new_size = supplement_filesystem(size_byte, False)
assert_that(new_size, equal_to(bitmath.GiB(1).to_Byte().value))
size_byte = bitmath.GiB(3).to_Byte().value
new_size = supplement_filesystem(size_byte, False)
assert_that(new_size, equal_to(bitmath.GiB(3).to_Byte().value))
def extend(self, new_size, user_cap=False):
sr = self.storage_resource
new_size = supplement_filesystem(new_size, user_cap)
param = self._cli.make_body(size=new_size)
resp = sr.modify_fs(fsParameters=param)
resp.raise_if_err()
return resp
def create_nfs_share(cls,
cli,
pool,
nas_server,
name,
size,
is_thin=None,
tiering_policy=None,
async_mode=True,
user_cap=False):
pool_clz = storops.unity.resource.pool.UnityPool
nas_server_clz = storops.unity.resource.nas_server.UnityNasServer
size = supplement_filesystem(size, user_cap)
pool = pool_clz.get(cli, pool)
nas_server = nas_server_clz.get(cli, nas_server)
proto = FSSupportedProtocolEnum.NFS
job_req_body = {
'description': 'Creating Filesystem and share',
'tasks': []
}
task_body = {
'action': 'createFilesystem',
'description': 'Create File System',
'name': 'CreateNewFilesystem',
'object': 'storageResource',
'parametersIn': {
'name': name,
'description': '',
'fsParameters': {},
'nfsShareCreate': []
}
}
fs_parameters = {
'pool': pool,
'nasServer': nas_server,
'supportedProtocols': proto,
'isThinEnabled': is_thin,
'size': size,
'fastVPParameters': {
'tieringPolicy': tiering_policy
}
}
nfs_share_create = {
'name': name,
'path': '/',
}
task_body['parametersIn']['fsParameters'] = cli.make_body(
fs_parameters)
task_body['parametersIn']['nfsShareCreate'].append(
cli.make_body(nfs_share_create))
job_req_body['tasks'].append(task_body)
resp = cli.post(cls().resource_class, **job_req_body)
resp.raise_if_err()
job = cls(_id=resp.resource_id, cli=cli)
if not async_mode:
job.wait_job_completion()
return job
def shrink(self, new_size, user_cap=False):
sr = self.storage_resource
new_size = supplement_filesystem(new_size, user_cap)
size_used = sr.size_used
if size_used and int(size_used) > new_size:
message = 'Reject shrink share request, ' \
'the new size should be larger than used.'
raise UnityShareShrinkSizeTooSmallError(message)
param = self._cli.make_body(size=new_size)
size_total = sr.size_total
if size_total and int(size_total) < new_size:
message = 'Reject shrink share request, ' \
'the new size should be smaller than original.'
raise UnityShareShrinkSizeTooLargeError(message)
resp = sr.modify_fs(fsParameters=param)
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 modify(self,
size=None,
is_thin=None,
tiering_policy=None,
user_cap=False,
is_compression=None,
access_policy=None,
locking_policy=None,
description=None,
cifs_fs_parameters=None):
sr = self.storage_resource
if sr is None:
raise ValueError(
'storage resource for filesystem {} not found.'.format(
self.name))
if size:
size = supplement_filesystem(size, user_cap)
fs_param = self.prepare_fs_parameters(is_thin_enabled=is_thin,
size=size,
tiering_policy=tiering_policy,
is_compression=is_compression,
access_policy=access_policy,
locking_policy=locking_policy)
params = {}
if fs_param:
params['fsParameters'] = fs_param
if cifs_fs_parameters:
params['cifsFsParameters'] = cifs_fs_parameters
if description is not None:
params['description'] = description
if not params:
return RestResponse('', self._cli)
req_body = self._cli.make_body(allow_empty=True, **params)
resp = sr.modify_fs(**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):
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
import storops
from storops.unity import enums
__author__ = 'Cedric Zhuang'
class UnityJob(UnityResource):
@classmethod
def create_nfs_share(cls, cli, pool, nas_server, name, size,
is_thin=None,
tiering_policy=None, async=True,
user_cap=False):
pool_clz = storops.unity.resource.pool.UnityPool
nas_server_clz = storops.unity.resource.nas_server.UnityNasServer
size = supplement_filesystem(size, user_cap)
pool = pool_clz.get(cli, pool)
nas_server = nas_server_clz.get(cli, nas_server)
proto = FSSupportedProtocolEnum.NFS
job_req_body = {
'description': 'Creating Filesystem and share',
'tasks': []
}
task_body = {
'action': 'createFilesystem',
'description': 'Create File System',
'name': 'CreateNewFilesystem',
'object': 'storageResource',
'parametersIn': {
'name': name,
def test_size_equal_1(self):
size_byte = bitmath.GiB(1).to_Byte().value
new_size = supplement_filesystem(size_byte, True)
assert_that(new_size, equal_to(bitmath.GiB(3).to_Byte().value))
def test_size_larger_2(self):
size_byte = bitmath.GiB(2.5).to_Byte().value
new_size = supplement_filesystem(size_byte, True)
assert_that(new_size, equal_to(bitmath.GiB(4).to_Byte().value))
assert_that(str(new_size).isdigit(), equal_to(True))
def create_nfs_share(cls,
cli,
pool,
nas_server,
name,
size,
is_thin=None,
tiering_policy=None,
async_mode=True,
user_cap=False,
path=None,
default_access=None,
min_security=None,
no_access_hosts=None,
read_only_hosts=None,
read_write_hosts=None,
root_access_hosts=None,
read_only_root_access_hosts=None,
no_access_hosts_string=None,
read_only_hosts_string=None,
read_write_hosts_string=None,
read_only_root_hosts_string=None,
root_access_hosts_string=None,
anonymous_uid=None,
anonymous_gid=None,
export_option=None):
pool_clz = storops.unity.resource.pool.UnityPool
nas_server_clz = storops.unity.resource.nas_server.UnityNasServer
size = supplement_filesystem(size, user_cap)
pool = pool_clz.get(cli, pool)
nas_server = nas_server_clz.get(cli, nas_server)
proto = FSSupportedProtocolEnum.NFS
job_req_body = {
'description': 'Creating Filesystem and share',
'tasks': []
}
task_body = {
'action': 'createFilesystem',
'description': 'Create File System',
'name': 'CreateNewFilesystem',
'object': 'storageResource',
'parametersIn': {
'name': name,
'description': '',
'fsParameters': {},
'nfsShareCreate': []
}
}
fs_parameters = {
'pool': pool,
'nasServer': nas_server,
'supportedProtocols': proto,
'isThinEnabled': is_thin,
'size': size,
'fastVPParameters': {
'tieringPolicy': tiering_policy
}
}
clz = storops.unity.resource.host.UnityHostList
no_access_hosts = clz.get_list(cli, no_access_hosts)
read_only_hosts = clz.get_list(cli, read_only_hosts)
read_write_hosts = clz.get_list(cli, read_write_hosts)
root_access_hosts = clz.get_list(cli, root_access_hosts)
read_only_root_access_hosts = clz.get_list(
cli, read_only_root_access_hosts)
nfs_share_clz = storops.unity.resource.nfs_share.UnityNfsShare
nfs_parameters = nfs_share_clz.prepare_nfs_share_parameters(
default_access=default_access,
min_security=min_security,
no_access_hosts=no_access_hosts,
read_only_hosts=read_only_hosts,
read_write_hosts=read_write_hosts,
root_access_hosts=root_access_hosts,
read_only_root_access_hosts=read_only_root_access_hosts,
no_access_hosts_string=no_access_hosts_string,
read_only_hosts_string=read_only_hosts_string,
read_write_hosts_string=read_write_hosts_string,
read_only_root_hosts_string=read_only_root_hosts_string,
root_access_hosts_string=root_access_hosts_string,
anonymous_uid=anonymous_uid,
anonymous_gid=anonymous_gid,
export_option=export_option)
path = path if path else '/'
nfs_share_create = {
'name': name,
'path': path,
'nfsShareParameters': nfs_parameters
}
task_body['parametersIn']['fsParameters'] = cli.make_body(
fs_parameters)
task_body['parametersIn']['nfsShareCreate'].append(
cli.make_body(nfs_share_create))
job_req_body['tasks'].append(task_body)
resp = cli.post(cls().resource_class, **job_req_body)
resp.raise_if_err()
job = cls(_id=resp.resource_id, cli=cli)
if not async_mode:
job.wait_job_completion()
return job