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': []}}))