type: int
partitions:
description: Node partition information.
type: complex
contains:
count:
description: Count of how many partitions are included.
type: int
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import re
LOG = utils.get_logger('dellemc_powerscale_node')
class PowerScaleClusterNode(object):
def __init__(self):
"""Define all the parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_node_parameters())
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False)
PREREQS_VALIDATE = utils.validate_module_pre_reqs(self.module.params)
if PREREQS_VALIDATE \
and not PREREQS_VALIDATE["all_packages_found"]:
description: IP address format.
type: str
groupnet:
description: Name of the groupnet this subnet belongs to.
type: str
pools:
description: List of names of pools in the subnet.
type: list
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import ipaddress
LOG = utils.get_logger('dellemc_powerscale_subnet')
class PowerScaleSubnet(object):
"""Class with operations on subnet"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(self.get_powerscale_subnet_parameters())
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False)
PREREQS_VALIDATE = utils.validate_module_pre_reqs(self.module.params)
type: str
name:
description: The name of the resource.
type: str
type_of_resource:
description: The resource's type is mentioned.
type: str
sample: "user"
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import re
LOG = utils.get_logger('dellemc_powerscale_group',
log_devel=utils.logging.INFO)
class PowerScaleGroup(object):
"""Class with group operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_group_parameters())
mutually_exclusive = [['group_name', 'group_id']]
required_one_of = [['group_name', 'group_id']]
# initialize the ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
description: The name of the policy.
type: str
id:
description: ID of the policy.
type: str
failover_failback_state:
description: The state of the policy with respect to sync
failover/failback.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_synciqpolicy')
class PowerScaleSynciqPolicy(object):
"""Class with SyncIQ Policy operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_synciqpolicy_parameters())
mutually_exclusive = [['policy_name', 'policy_id']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
mutually_exclusive=mutually_exclusive)
PREREQS_VALIDATE = utils.validate_module_pre_reqs(self.module.params)
name:
description: Specifies the name of the LDAP provider.
type: str
server_uris:
description: Specifies the server URIs.
type: str
status:
description: Specifies the status of the provider.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_ldap')
class PowerScaleLdap(object):
"""Class with LDAP provider operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_ldap_parameters())
required_together = [['server_uris', 'server_uri_state']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
required_together=required_together)
description: The Quota usage.
type: dict
sample: {
"inodes": 1,
"logical": 0,
"physical": 2048
}
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import re
import copy
LOG = utils.get_logger('dellemc_powerscale_smartquota',
log_devel=utils.logging.INFO)
class PowerScaleSmartQuota(object):
"""Class with Smart Quota operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_smartquota_parameters())
mut_ex_args = [['group_name', 'user_name']]
req_if_args = [['quota_type', 'user', ['user_name']],
['quota_type', 'group', ['group_name']]]
# initialize the ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
type: str
pool:
description: Name of pool to which this rule belongs
type: str
subnet:
description: Name of subnet to which this rule belongs
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_network_rule')
class PowerScaleNetworkRule(object):
"""Class with Network Provisioning Rule operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_network_rule_parameters())
# initialize the Ansible module
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=False
)
description: Unique Groupnet ID.
type: str
name:
description: Name of groupnet
type: str
subnets:
description: List of names of the subnets in the groupnet
type: list
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import ipaddress
LOG = utils.get_logger('dellemc_powerscale_groupnet')
class PowerScaleGroupnet(object):
"""Class with operations on groupnet"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(self.get_powerscale_groupnet_parameters())
required_together = [['dns_servers', 'dns_server_state'],
['dns_search_suffix', 'dns_search_suffix_state']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
required_together=required_together)
dellemc_powerscale_gatherfacts:
onefs_host: "{{onefs_host}}"
verify_ssl: "{{verify_ssl}}"
api_user: "******"
api_password: "******"
gather_subset:
- network_subnets
'''
RETURN = r''' '''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_gatherfacts')
class PowerScaleGatherFacts(object):
"""Class with Gather Fact operations"""
def __init__(self):
"""Define all the parameters required by this module"""
self.module_params = utils \
.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_gatherfacts_parameters())
mutually_exclusive_args = [['access_zone', 'include_all_access_zones']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
type: int
static_routes:
description: List of interface members in this pool.
type: list
subnet:
description: The name of the subnet.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import ipaddress
# initialize the logger
LOG = utils.get_logger('dellemc_powerscale_networkpool')
class PowerScaleNetworkPool(object):
"""Class with Network Pool operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_network_pool_parameters())
# initialize the ansible module
self.module = AnsibleModule(argument_spec=self.module_params)
# result is a dictionary that contains changed status and
self.result = {"changed": False}
type: complex
contains:
id:
description: A unique identifier for this object.
type: str
state:
description: The state of the job.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_synciqjob')
class PowerScaleSyncIQJob(object):
"""Class with SyncIQ job operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_synciqjob_parameters())
# initialize the Ansible module
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=False
)
clients:
description: The list of clients for the NFS Export.
type: list
sample: ['client_ip', 'client_ip']
description:
description: Description for the export.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
import logging
import re
LOG = utils.get_logger(module_name='dellemc_powerscale_nfs',
log_devel=logging.INFO)
class PowerScaleNfsExport(object):
'''Class with NFS export operations'''
def __init__(self):
''' Define all parameters required by this module'''
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(self.get_powerscale_nfs_parameters())
# Initialize the ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False)
# Result is a dictionary that contains changed status, NFS export
# details
self.result = {"changed": False, "NFS_export_details": {}}
PREREQS_VALIDATE = utils.validate_module_pre_reqs(self.module.params)
id:
description: Field id.
type: str
key:
description: Key value from key_file that maps to this server.
type: str
name:
description: NTP server name.
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_setting')
class PowerScaleSettings(object):
"""Class with general setting operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_setting_parameters())
# initialize the ansible module
self.module = AnsibleModule(argument_spec=self.module_params)
# result is a dictionary that contains changed status and
self.result = {"changed": False}
target_name:
description: target name of snapshot whose alias it is.
type: str
sample: "ansible_target_snap"
'''
import logging
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
from datetime import datetime, timedelta
import calendar
import time
import re
LOG = utils.get_logger('dellemc_powerscale_snapshot',
log_devel=logging.INFO)
class PowerScaleSnapshot(object):
"""Class with Snapshot operations"""
def __init__(self):
"""Define all the parameters required by this module"""
self.module_params = utils \
.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_snapshot_parameters())
mutually_exclusive = [
['desired_retention', 'expiration_timestamp'],
['expiration_timestamp', 'retention_unit']
description: Type of performance rule
type: str
schedule:
description: Duration when performance rule is effective
type: str
limit:
description: Amount the specified system resource type is limited by this rule
type: int
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_synciqrules')
class PowerScaleSynciqRules(object):
"""Class with SyncIQ Performance Rules operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_synciqrules_parameters())
# initialize the Ansible module
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=False
type: str
directory_create_mode(octal):
description: UNIX mode bits for directory in octal format
type: str
file_create_mask(octal):
description: UNIX mask bits for file in octal format
type: str
file_create_mode(octal):
description: UNIX mode bits for file in octal format
type: str
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_accesszone')
class PowerScaleAccessZone(object):
"""Class with access zone operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_accesszone_parameters())
required_together = [['auth_providers', 'provider_state']]
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False,
required_together=required_together)
type: str
sample: "/ifs/ansible/ansible281825"
id:
description: The id of the snapshot.
type: int
sample: 1524
'''
import re
import logging
import copy
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_filesystem',
log_devel=logging.INFO)
class PowerScaleFileSystem(object):
"""Class with Filesystem operations"""
def __init__(self):
"""Define all the parameters required by this module"""
self.module_params = utils \
.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_filesystem_parameters())
# initialize the Ansible module
self.module = AnsibleModule(argument_spec=self.module_params,
supports_check_mode=False
description: A list of warning messages for this job.
type: list
elements: str
worm_committed_file_conflicts:
description: The number of WORM committed files which needed to be reverted.
Since WORM committed files cannot be reverted,
this is the number of files that were preserved in the compliance store.
type: int
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_synciqtargetreports')
class PowerScaleSyncIQTargetReports(object):
"""Class with SyncIQ Target Reports"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_synciq_target_reports_parameters())
mutually_exclusive = [['id', 'name']]
required_one_of = [
['id', 'name']
instance.
type: str
name:
description: Specifies the Active Directory provider name.
type: str
login_shell:
description: Specifies the login shell path.
type: str
'''
import re
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.powerscale.plugins.module_utils.storage.dell \
import dellemc_ansible_powerscale_utils as utils
LOG = utils.get_logger('dellemc_powerscale_ads')
class PowerScaleAds(object):
"""Class with Active Directory provider operations"""
def __init__(self):
""" Define all parameters required by this module"""
self.module_params = utils.get_powerscale_management_host_parameters()
self.module_params.update(get_powerscale_ads_parameters())
required_one_of = [['domain_name', 'instance_name']]
# initialize the Ansible module
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=False,
