def prepare_lun_parameters(**kwargs):
sp = kwargs.get('sp')
if isinstance(sp, UnityStorageProcessor):
sp_node = sp.to_node_enum()
elif isinstance(sp, NodeEnum):
sp_node = sp
else:
sp_node = NodeEnum.parse(sp)
NodeEnum.verify(sp_node)
TieringPolicyEnum.verify(kwargs.get('tiering_policy'))
lun_parameters = UnityClient.make_body(
isThinEnabled=kwargs.get('is_thin'),
isCompressionEnabled=kwargs.get('is_compression'),
size=kwargs.get('size'),
pool=kwargs.get('pool'),
defaultNode=sp_node,
fastVPParameters=UnityClient.make_body(
tieringPolicy=kwargs.get('tiering_policy')),
ioLimitParameters=UnityClient.make_body(
ioLimitPolicy=kwargs.get('io_limit_policy')))
# Empty host access can be used to wipe the host_access
host_access = UnityClient.make_body(kwargs.get('host_access'),
allow_empty=True)
if host_access is not None:
lun_parameters['hostAccess'] = host_access
return lun_parameters
def prepare_user_quota_create_parameters(filesystem=None,
tree_quota=None,
hard_limit=None,
soft_limit=None,
uid=None,
unix_name=None,
win_name=None):
"""
Prepare user_quota for the create operation
:param filesystem: This is needed if the user_quota is to be
created on the filesystem
:param tree_quota: This is needed if the user_quota is to be
created on the tree_quota
:param hard_limit: hard_limit for the user_quota
:param soft_limit: soft_limit for the user_quota
:param uid: uid of the user
:param unix_name: unix_name of the user
:param win_name: windows name of the user
:return: user_quota_params for create user_quota preparation
"""
user_quota_param = UnityClient.make_body(filesystem=filesystem,
treeQuota=tree_quota,
hardLimit=hard_limit,
softLimit=soft_limit,
uid=uid,
unixName=unix_name,
winName=win_name)
return user_quota_param
def prepare_nfs_share_parameters(**kwargs):
default_access = kwargs.get('default_access')
min_security = kwargs.get('min_security')
NFSShareDefaultAccessEnum.verify(default_access)
NFSShareSecurityEnum.verify(min_security)
nfs_share_param = UnityClient.make_body(
allow_empty=True,
defaultAccess=default_access,
minSecurity=min_security,
noAccessHosts=kwargs.get('no_access_hosts'),
readOnlyHosts=kwargs.get('read_only_hosts'),
readWriteHosts=kwargs.get('read_write_hosts'),
rootAccessHosts=kwargs.get('root_access_hosts'),
readOnlyRootAccessHosts=kwargs.get('read_only_root_access_hosts'),
noAccessHostsString=kwargs.get('no_access_hosts_string'),
readOnlyHostsString=kwargs.get('read_only_hosts_string'),
readWriteHostsString=kwargs.get('read_write_hosts_string'),
readOnlyRootHostsString=kwargs.get('read_only_root_hosts_string'),
readWriteRootHostsString=kwargs.get('root_access_hosts_string'),
anonymousUID=kwargs.get('anonymous_uid'),
anonymousGID=kwargs.get('anonymous_gid'),
exportOption=kwargs.get('export_option'),
description=kwargs.get('description'))
return nfs_share_param
def test_make_body_blank(self):
param = {'fastVPParameters': {
'tieringPolicy': None
}}
ret = UnityClient.make_body(param)
expected = {}
assert_that(ret, equal_to(expected))
def test_make_body_blank(self):
param = {}
param['fastVPParameters'] = {
'tieringPolicy': None
}
ret = UnityClient.make_body(param)
expected = {}
assert_that(ret, equal_to(expected))
def test_make_body_nested_empty_dict(self):
param = {
'name': 'abc',
'replicationParameters': {
'isReplicationDestination': None,
}
}
ret = UnityClient.make_body(param)
assert_that(ret, equal_to({'name': 'abc'}))
def test_make_body_nested_empty_dict(self):
param = {
'name': 'abc',
'replicationParameters': {
'isReplicationDestination': None,
}
}
ret = UnityClient.make_body(param)
assert_that(ret, equal_to({'name': 'abc'}))
def prepare_lun_parameters(cli=None, **kwargs):
@version('<4.3')
def make_compression_body(cli=None, is_compression=None):
return UnityClient.make_body(isCompressionEnabled=is_compression)
@version('>=4.3') # noqa
def make_compression_body(cli=None, is_compression=None):
return UnityClient.make_body(isDataReductionEnabled=is_compression)
sp = kwargs.get('sp')
if isinstance(sp, UnityStorageProcessor):
sp_node = sp.to_node_enum()
elif isinstance(sp, NodeEnum):
sp_node = sp
else:
sp_node = NodeEnum.parse(sp)
NodeEnum.verify(sp_node)
TieringPolicyEnum.verify(kwargs.get('tiering_policy'))
lun_parameters = UnityClient.make_body(
isThinEnabled=kwargs.get('is_thin'),
size=kwargs.get('size'),
pool=kwargs.get('pool'),
defaultNode=sp_node,
fastVPParameters=UnityClient.make_body(
tieringPolicy=kwargs.get('tiering_policy')),
ioLimitParameters=UnityClient.make_body(
ioLimitPolicy=kwargs.get('io_limit_policy')),
isAdvancedDedupEnabled=kwargs.get('is_advanced_dedup_enabled'))
compression_body = make_compression_body(cli, kwargs.get('is_compression'))
lun_parameters.update(compression_body)
# Empty host access can be used to wipe the host_access
host_access = UnityClient.make_body(kwargs.get('host_access'),
allow_empty=True)
if host_access is not None:
lun_parameters['hostAccess'] = host_access
return lun_parameters
def prepare_cifs_fs_parameters(is_cifs_sync_writes_enabled=None,
is_cifs_op_locks_enabled=None,
is_cifs_notify_on_write_enabled=None,
is_cifs_notify_on_access_enabled=None,
cifs_notify_on_change_dir_depth=None):
return UnityClient.make_body(
allow_empty=True,
isCIFSSyncWritesEnabled=is_cifs_sync_writes_enabled,
isCIFSOpLocksEnabled=is_cifs_op_locks_enabled,
isCIFSNotifyOnWriteEnabled=is_cifs_notify_on_write_enabled,
isCIFSNotifyOnAccessEnabled=is_cifs_notify_on_access_enabled,
cifsNotifyOnChangeDirDepth=cifs_notify_on_change_dir_depth)
def test_make_body_complex(self):
service_levels = [ServiceLevelEnum.BASIC, ServiceLevelEnum.BRONZE]
param = {
'a': 1,
'b': UnityLun(_id='lun1'),
'c': UnityLunList(cli=t_rest()),
'd': [UnityLun(_id='lun10'),
UnityLun(_id='lun11'), 0.1],
'e': {
'f': UnityLun(_id='lun12')
},
'g': 'string',
'h': 0.2,
'i': service_levels,
'j': ServiceLevelEnumList.parse(service_levels)
}
ret = UnityClient.make_body(param)
expected = {
'a':
1,
'b': {
'id': 'lun1'
},
'c': [{
'id': 'sv_2'
}, {
'id': 'sv_3'
}, {
'id': 'sv_5'
}, {
'id': 'sv_6'
}, {
'id': 'sv_7'
}],
'd': [{
'id': 'lun10'
}, {
'id': 'lun11'
}, 0.1],
'e': {
'f': {
'id': 'lun12'
}
},
'g':
'string',
'h':
0.2,
'i': [0, 1],
'j': [0, 1]
}
assert_that(ret, equal_to(expected))
def prepare_fs_parameters(**kwargs):
@version('<4.3')
def make_compression_body(is_compression=None):
return UnityClient.make_body(allow_empty=True,
isCompressionEnabled=is_compression)
@version('>=4.3') # noqa
def make_compression_body(is_compression=None):
return UnityClient.make_body(allow_empty=True,
isDataReductionEnabled=is_compression)
access_policy = kwargs.get('access_policy')
locking_policy = kwargs.get('locking_policy')
supported_protocols = kwargs.get('supported_protocols')
tiering_policy = kwargs.get('tiering_policy')
AccessPolicyEnum.verify(access_policy)
FSSupportedProtocolEnum.verify(supported_protocols)
FSLockingPolicyEnum.verify(locking_policy)
TieringPolicyEnum.verify(tiering_policy)
fs_param = UnityClient.make_body(
allow_empty=True,
pool=kwargs.get('pool'),
nasServer=kwargs.get('nas_server'),
supportedProtocols=supported_protocols,
isThinEnabled=kwargs.get('is_thin_enabled'),
size=kwargs.get('size'),
accessPolicy=access_policy,
lockingPolicy=locking_policy)
if tiering_policy:
fs_param['fastVPParameters'] = UnityClient.make_body(
allow_empty=True, tieringPolicy=tiering_policy)
compression_body = make_compression_body(kwargs.get('is_compression'))
fs_param.update(compression_body)
return fs_param
def prepare_cifs_share_parameters(**kwargs):
offline_availability = kwargs.get('offline_availability')
CifsShareOfflineAvailabilityEnum.verify(offline_availability)
cifs_share_param = UnityClient.make_body(
allow_empty=True,
isReadOnly=kwargs.get('is_read_only'),
isEncryptionEnabled=kwargs.get('is_encryption_enabled'),
isContinuousAvailabilityEnabled=kwargs.get(
'is_con_avail_enabled'),
isACEEnabled=kwargs.get('is_ace_enabled'),
addACE=kwargs.get('add_ace'),
deleteACE=kwargs.get('delete_ace'),
isABEEnabled=kwargs.get('is_abe_enabled'),
isBranchCacheEnabled=kwargs.get('is_branch_cache_enabled'),
offlineAvailability=offline_availability,
umask=kwargs.get('umask'),
description=kwargs.get('description'))
return cifs_share_param
def test_make_body_complex(self):
service_levels = [ServiceLevelEnum.BASIC, ServiceLevelEnum.BRONZE]
param = {
'a': 1,
'b': UnityLun(_id='lun1'),
'c': UnityLunList(cli=t_rest()),
'd': [UnityLun(_id='lun10'), UnityLun(_id='lun11'), 0.1],
'e': {'f': UnityLun(_id='lun12')},
'g': 'string',
'h': 0.2,
'i': service_levels,
'j': ServiceLevelEnumList.parse(service_levels)
}
ret = UnityClient.make_body(param)
expected = {'a': 1,
'b': {'id': 'lun1'},
'c': [{'id': 'sv_2'}, {'id': 'sv_3'},
{'id': 'sv_5'}, {'id': 'sv_6'},
{'id': 'sv_7'}],
'd': [{'id': 'lun10'}, {'id': 'lun11'}, 0.1],
'e': {'f': {'id': 'lun12'}},
'g': 'string', 'h': 0.2, 'i': [0, 1], 'j': [0, 1]}
assert_that(ret, equal_to(expected))
def test_make_body_empty_dict(self):
inner = UnityClient.make_body(a=None)
outer = UnityClient.make_body(b=inner, c=3)
assert_that(outer, equal_to({'c': 3}))
def test_make_body_zero(self):
ret = UnityClient.make_body(a=0, b='')
assert_that(ret, equal_to({'a': 0, 'b': ''}))
def test_make_body_nested_empty_collection(self):
ret = UnityClient.make_body(allow_empty=True, b=(), c={'d': []})
assert_that(ret, equal_to({'b': [], 'c': {'d': []}}))
def test_make_body_enum(self):
ret = UnityClient.make_body({'a': RaidTypeEnum.RAID5})
assert_that(ret, equal_to({'a': 1}))
def test_make_body_kwargs(self):
ret = UnityClient.make_body(a=1, b='c')
assert_that(ret, equal_to({'a': 1, 'b': 'c'}))
def test_make_body_resource(self):
ret = UnityClient.make_body(UnityLun(_id='abc'))
assert_that(ret, equal_to({'id': 'abc'}))
def test_make_body_kwargs(self):
ret = UnityClient.make_body(a=1, b='c')
assert_that(ret, equal_to({'a': 1, 'b': 'c'}))
def test_make_body_resource(self):
ret = UnityClient.make_body(UnityLun(_id='abc'))
assert_that(ret, equal_to({'id': 'abc'}))
def test_make_body_no_change(self):
ret = UnityClient.make_body(True)
assert_that(ret, equal_to(True))
ret = UnityClient.make_body('string')
assert_that(ret, equal_to('string'))
def test_make_body_empty_dict(self):
inner = UnityClient.make_body(a=None)
outer = UnityClient.make_body(b=inner, c=3)
assert_that(outer, equal_to({'c': 3}))
def test_make_body_None(self):
ret = UnityClient.make_body({'a': None})
assert_that(ret, equal_to({}))
def test_make_body_no_change(self):
ret = UnityClient.make_body(True)
assert_that(ret, equal_to(True))
ret = UnityClient.make_body('string')
assert_that(ret, equal_to('string'))
def make_compression_body(is_compression=None):
return UnityClient.make_body(allow_empty=True,
isDataReductionEnabled=is_compression)
def test_make_body_None(self):
ret = UnityClient.make_body({'a': None})
assert_that(ret, equal_to({}))
def test_make_body_zero(self):
ret = UnityClient.make_body(a=0, b='')
assert_that(ret, equal_to({'a': 0, 'b': ''}))
def test_make_body_enum(self):
ret = UnityClient.make_body({'a': RaidTypeEnum.RAID5})
assert_that(ret, equal_to({'a': 1}))
def make_compression_body(cli=None, is_compression=None):
return UnityClient.make_body(isDataReductionEnabled=is_compression)
def test_make_body_nested_empty_collection(self):
ret = UnityClient.make_body(allow_empty=True, b=(), c={'d': []})
assert_that(ret, equal_to({'b': [], 'c': {'d': []}}))
