def __init__(self):
"""
Initialize the NetAppOntapServiceProcessorNetwork class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present'],
default='present'),
address_type=dict(required=True, choices=['ipv4', 'ipv6']),
is_enabled=dict(required=True, type='bool'),
node=dict(required=True, type='str'),
dhcp=dict(required=False, choices=['v4', 'none']),
gateway_ip_address=dict(required=False, type='str'),
ip_address=dict(required=False, type='str'),
netmask=dict(required=False, type='str'),
prefix_length=dict(required=False, type='int'),
wait_for_completion=dict(required=False,
type='bool',
default=False)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
self.set_playbook_zapi_key_map()
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module,
vserver=None)
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
interface_name=dict(required=True, type='str'),
home_node=dict(required=False, type='str', default=None),
home_port=dict(required=False, type='str'),
role=dict(required=False, type='str'),
address=dict(required=False, type='str'),
netmask=dict(required=False, type='str'),
vserver=dict(required=True, type='str'),
firewall_policy=dict(required=False, type='str',
default=None),
failover_policy=dict(required=False, type='str',
default=None),
admin_status=dict(required=False, choices=['up', 'down']),
subnet_name=dict(required=False, type='str'),
is_auto_revert=dict(required=False, type=bool, default=None),
protocols=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=[
'present', 'absent'], default='present'),
service_state=dict(required=False, choices=[
'started', 'stopped'], default=None),
vserver=dict(required=True, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
params = self.module.params
# set up state variables
self.state = params['state']
self.service_state = params['service_state']
if self.state == 'present' and self.service_state is None:
self.service_state = 'started'
self.vserver = params['vserver']
self.is_started = None
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.vserver)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
share_name=dict(required=True, type='str'),
path=dict(required=False, type='str'),
vserver=dict(required=True, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[('state', 'present',
['share_name', 'path'])],
supports_check_mode=True)
parameters = self.module.params
# set up state variables
self.state = parameters['state']
self.share_name = parameters['share_name']
self.path = parameters['path']
self.vserver = parameters['vserver']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.vserver)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present'],
default='present'),
destination_vserver=dict(required=True, type='str'),
destination_path=dict(required=True, type='str'),
source_path=dict(required=True, type='str'),
source_vserver=dict(required=False, type='str'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module,
vserver=self.parameters['destination_vserver'])
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False, default='present'),
vserver=dict(required=True, type='str'),
volumes=dict(required=True, type='list'),
snapshot=dict(required=True, type='str'),
timeout=dict(required=False,
type='str',
choices=['urgent', 'medium', 'relaxed'],
default='medium'),
snapmirror_label=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
parameters = self.module.params
# set up variables
self.state = parameters['state']
self.vserver = parameters['vserver']
self.volumes = parameters['volumes']
self.snapshot = parameters['snapshot']
self.timeout = parameters['timeout']
self.snapmirror_label = parameters['snapmirror_label']
self.cgid = None
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.vserver)
def __init__(self):
"""
Initialize the Ontap Net Route class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
vserver=dict(required=True, type='str'),
destination=dict(required=True, type='str'),
gateway=dict(required=True, type='str'),
metric=dict(required=False, type='str'),
from_destination=dict(required=False, type='str',
default=None),
from_gateway=dict(required=False, type='str', default=None),
from_metric=dict(required=False, type='str', default=None),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def __init__(self):
"""
Initialize the Ontap IfGrp class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
distribution_function=dict(required=False, type='str', choices=['mac', 'ip', 'sequential', 'port']),
name=dict(required=True, type='str'),
mode=dict(required=False, type='str'),
node=dict(required=True, type='str'),
ports=dict(required=False, type='list', aliases=["port"]),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_if=[
('state', 'present', ['distribution_function', 'mode'])
],
supports_check_mode=True
)
# set up variables
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=[
'present', 'absent'], default='present'),
from_name=dict(required=False, type='str'),
snapshot=dict(required=True, type="str"),
volume=dict(required=True, type="str"),
async_bool=dict(required=False, type="bool", default=False),
comment=dict(required=False, type="str"),
snapmirror_label=dict(required=False, type="str"),
ignore_owners=dict(required=False, type="bool", default=False),
snapshot_instance_uuid=dict(required=False, type="str"),
vserver=dict(required=True, type="str"),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
allow_list=dict(required=False, type="list"),
policy=dict(required=False, type='str'),
service=dict(required=False, type='str', choices=['dns', 'http', 'https', 'ndmp',
'ndmps', 'ntp', 'rsh', 'snmp', 'ssh', 'telnet']),
vserver=dict(required=False, type="str"),
enable=dict(required=False, type="str", choices=['enable', 'disable']),
logging=dict(required=False, type="str", choices=['enable', 'disable']),
node=dict(required=False, type="str")
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_together=(['policy', 'service', 'vserver'],
['enable', 'node']
),
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
if HAS_IPADDRESS_LIB is False:
self.module.fail_json(msg="the python ipaddress lib is required for this module")
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type='str'),
command_directory_name=dict(required=True, type='str'),
access_level=dict(required=False,
type='str',
default='all',
choices=['none', 'readonly', 'all']),
vserver=dict(required=True, type='str'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
parameters = self.module.params
# set up state variables
self.state = parameters['state']
self.name = parameters['name']
self.command_directory_name = parameters['command_directory_name']
self.access_level = parameters['access_level']
self.vserver = parameters['vserver']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
nodes=dict(required=False, type='list', aliases=["node"]),
package_version=dict(required=True, type='str'),
package_url=dict(required=True, type='str'),
ignore_validation_warning=dict(required=False,
type='bool',
default=False)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
cross_junction=dict(required=False, type='bool', default=False),
directory_recursion=dict(required=False, type='bool', default=False),
file_ext_to_exclude=dict(required=False, type="list"),
file_ext_to_include=dict(required=False, type="list"),
max_file_size=dict(required=False, type="str"),
paths_to_exclude=dict(required=False, type="list"),
report_directory=dict(required=False, type='str'),
report_log_level=dict(required=False, choices=['verbose', 'info', 'error'], default='error'),
request_timeout=dict(required=False, type='str'),
scan_files_with_no_ext=dict(required=False, type='bool', default=True),
scan_paths=dict(required=False, type="list"),
scan_priority=dict(required=False, choices=['low', 'normal'], default='low'),
schedule=dict(required=False, type="str"),
task_name=dict(required=True, type="str")
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True,
required_if=[
["state", "present", ["report_directory", "scan_paths"]]
]
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def __init__(self):
"""
Initialize the ONTAP Broadcast Domain class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True,
type='str',
aliases=["broadcast_domain"]),
ipspace=dict(required=False, type='str'),
mtu=dict(required=False, type='str'),
ports=dict(required=False, type='list'),
from_name=dict(required=False, type='str'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def __init__(self):
argument_spec = netapp_utils.na_ontap_host_argument_spec()
argument_spec.update(
dict(state=dict(required=False,
default='present',
choices=['present', 'absent']),
vserver=dict(required=True, type='str'),
message=dict(default='', type='str'),
show_cluster_motd=dict(default=True, type='bool')))
self.module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_XMLTODICT_LIB is False:
self.module.fail_json(
msg="the python xmltodict module is required")
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
volume=dict(required=True, type='str'),
quota_target=dict(required=True, type='str'),
qtree=dict(required=False, type='str', default=""),
type=dict(required=True, type='str', choices=['user', 'group', 'tree']),
policy=dict(required=False, type='str'),
set_quota_status=dict(required=False, type='bool'),
file_limit=dict(required=False, type='str', default='-'),
disk_limit=dict(required=False, type='str', default='-'),
threshold=dict(required=False, type='str', default='-')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def __init__(self):
"""
Initialize the ONTAP Broadcast Domain class
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
broadcast_domain=dict(required=True, type='str'),
ipspace=dict(required=False, type='str'),
mtu=dict(required=False, type='str'),
ports=dict(required=False, type='list'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
parameters = self.module.params
# set up state variables
self.state = parameters['state']
self.broadcast_domain = parameters['broadcast_domain']
self.ipspace = parameters['ipspace']
self.mtu = parameters['mtu']
self.ports = parameters['ports']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type="str"),
enabled=dict(required=False, type="bool"),
# count is a list of integers
count=dict(required=False, type="list", elements="int"),
comment=dict(required=False, type="str"),
schedule=dict(required=False, type="list", elements="str")))
self.module = AnsibleModule(argument_spec=self.argument_spec,
required_if=[
('state', 'present',
['enabled', 'count', 'schedule']),
],
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
node_name=dict(required=True, type='str'),
transport=dict(required=False,
type='str',
choices=['smtp', 'http', 'https']),
noteto=dict(required=False, type='list'),
post_url=dict(reuired=False, type='str'),
support=dict(required=False, type='bool'),
mail_hosts=dict(required=False, type='list')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=False)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
# present or absent requires modifying state to enabled or disabled
self.parameters['service_state'] = 'started' if self.parameters[
'state'] == 'present' else 'stopped'
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str', default=None),
ostype=dict(required=False, type='str'),
initiator_group_type=dict(required=False,
type='str',
choices=['fcp', 'iscsi', 'mixed']),
initiators=dict(required=False,
type='list',
aliases=['initiator']),
vserver=dict(required=True, type='str'),
force_remove_initiator=dict(required=False,
type='bool',
default=False),
bind_portset=dict(required=False, type='str')))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.parameters['vserver'])
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present'],
default='present'),
adapter_name=dict(required=True, type='str'),
node_name=dict(required=True, type='str'),
mode=dict(required=False, type='str'),
type=dict(required=False, type='str'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
params = self.module.params
# set up state variables
self.state = params['state']
self.adapter_name = params['adapter_name']
self.node_name = params['node_name']
self.mode = params['mode']
self.type = params['type']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def main():
'''Execute action'''
argument_spec = netapp_utils.na_ontap_host_argument_spec()
argument_spec.update(
dict(
state=dict(type='str', default='info', choices=['info']),
gather_subset=dict(default=['all'], type='list'),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_XMLTODICT:
module.fail_json(msg="xmltodict missing")
if not HAS_JSON:
module.fail_json(msg="json missing")
state = module.params['state']
gather_subset = module.params['gather_subset']
if gather_subset is None:
gather_subset = ['all']
gf_obj = NetAppONTAPGatherInfo(module)
gf_all = gf_obj.get_all(gather_subset)
result = {'state': state, 'changed': False}
module.exit_json(ontap_info=gf_all, **result)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
subsystem=dict(required=True, type='str'),
ostype=dict(required=False, type='str', choices=['windows', 'linux', 'vmware', 'xen', 'hyper_v']),
skip_host_check=dict(required=False, type='bool', default=False),
skip_mapped_check=dict(required=False, type='bool', default=False),
hosts=dict(required=False, type='list'),
paths=dict(required=False, type='list')
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(
state=dict(required=False,
choices=['present', 'absent'],
default='present'),
serial_number=dict(required=False, type='str'),
remove_unused=dict(default=None, type='bool'),
remove_expired=dict(default=None, type='bool'),
license_codes=dict(default=None, type='list'),
license_names=dict(default=None, type='list'),
))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=False,
required_if=[
('state', 'absent',
['serial_number', 'license_names'])
])
parameters = self.module.params
# set up state variables
self.state = parameters['state']
self.serial_number = parameters['serial_number']
self.remove_unused = parameters['remove_unused']
self.remove_expired = parameters['remove_expired']
self.license_codes = parameters['license_codes']
self.license_names = parameters['license_names']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
name=dict(required=True, type='str'),
applications=dict(required=True, type='list', aliases=['application'],
choices=['console', 'http', 'ontapi', 'rsh', 'snmp',
'sp', 'service-processor', 'ssh', 'telnet'],),
authentication_method=dict(required=True, type='str',
choices=['community', 'password',
'publickey', 'domain',
'nsswitch', 'usm']),
set_password=dict(required=False, type='str', no_log=True),
role_name=dict(required=False, type='str'),
lock_user=dict(required=False, type='bool'),
vserver=dict(required=True, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
required_if=[
('state', 'present', ['role_name'])
],
supports_check_mode=True
)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
def __init__(self):
"""
Initialize the Ontap qos policy group class.
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
type='str',
choices=['present', 'absent'],
default='present'),
name=dict(required=True, type='str'),
from_name=dict(required=False, type='str'),
vserver=dict(required=True, type='str'),
max_throughput=dict(required=False, type='str'),
min_throughput=dict(required=False, type='str'),
force=dict(required=False, type='bool', default=False)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
self.na_helper = NetAppModule()
self.parameters = self.na_helper.set_parameters(self.module.params)
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
"""
Initializes the NetAppOntapVlan function
"""
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=False, choices=['present', 'absent'], default='present'),
parent_interface=dict(required=True, type='str'),
vlanid=dict(required=True, type='str'),
node=dict(required=True, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
p = self.module.params
# set up state variables
self.state = p['state']
self.parent_interface = p['parent_interface']
self.vlanid = p['vlanid']
self.node = p['node']
self.interface_name = str(p['parent_interface']) + '-' + str(self.vlanid)
if HAS_NETAPP_LIB is False:
self.module.fail_json(msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
return
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(choices=['present', 'absent'], default='present'),
vserver=dict(required=True, type='str'),
hostnames=dict(requried=False, type='list'),
privileged_users=dict(required=False, type='list'),
scanner_pool=dict(required=True, type='str'),
scanner_policy=dict(required=False,
choices=['primary', 'secondary',
'idle'])))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
parameters = self.module.params
self.hostnames = parameters['hostnames']
self.vserver = parameters['vserver']
self.privileged_users = parameters['privileged_users']
self.scanner_pool = parameters['scanner_pool']
self.state = parameters['state']
self.scanner_policy = parameters['scanner_policy']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(
module=self.module, vserver=self.vserver)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(state=dict(required=False,
choices=['present'],
default='present'),
cluster_name=dict(required=False, type='str'),
cluster_ip_address=dict(required=False, type='str'),
license_code=dict(required=False, type='str'),
license_package=dict(required=False, type='str'),
node_serial_number=dict(required=False, type='str')))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True,
required_together=[['license_package', 'node_serial_number']],
mutually_exclusive=[
['cluster_name', 'cluster_ip_address'],
])
parameters = self.module.params
# set up state variables
self.state = parameters['state']
self.cluster_ip_address = parameters['cluster_ip_address']
self.cluster_name = parameters['cluster_name']
self.license_code = parameters['license_code']
self.license_package = parameters['license_package']
self.node_serial_number = parameters['node_serial_number']
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
def __init__(self):
self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
self.argument_spec.update(
dict(command=dict(required=True, type='list'),
privilege=dict(required=False,
type='str',
choices=['admin', 'advanced'],
default='admin'),
return_dict=dict(required=False, type='bool', default=False)))
self.module = AnsibleModule(argument_spec=self.argument_spec,
supports_check_mode=True)
parameters = self.module.params
# set up state variables
self.command = parameters['command']
self.privilege = parameters['privilege']
self.return_dict = parameters['return_dict']
self.result_dict = dict()
self.result_dict['status'] = ""
self.result_dict['result_value'] = 0
self.result_dict['invoked_command'] = " ".join(self.command)
self.result_dict['stdout'] = ""
self.result_dict['stdout_lines'] = []
self.result_dict['xml_dict'] = dict()
if HAS_NETAPP_LIB is False:
self.module.fail_json(
msg="the python NetApp-Lib module is required")
else:
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
