def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"system_nat64": {
"required": False,
"type": "dict",
"default": None,
"options": {
"always_synthesize_aaaa_record": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"generate_ipv6_fragment_header": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"nat46_force_ipv4_packet_forwarding": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"nat64_prefix": {
"required": False,
"type": "str"
},
"secondary_prefix": {
"required": False,
"type": "list",
"options": {
"name": {
"required": True,
"type": "str"
},
"nat64_prefix": {
"required": False,
"type": "str"
}
}
},
"secondary_prefix_status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"switch_controller_qos_dot1p_map": {
"required": False, "type": "dict", "default": None,
"options": {
"description": {"required": False, "type": "str"},
"name": {"required": True, "type": "str"},
"priority_0": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_1": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_2": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_3": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_4": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_5": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_6": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]},
"priority_7": {"required": False, "type": "str",
"choices": ["queue-0", "queue-1", "queue-2",
"queue-3", "queue-4", "queue-5",
"queue-6", "queue-7"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_switch_controller_qos(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_switch_controller_qos(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"system_cluster_sync": {
"required": False, "type": "dict", "default": None,
"options": {
"down_intfs_before_sess_sync": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"hb_interval": {"required": False, "type": "int"},
"hb_lost_threshold": {"required": False, "type": "int"},
"peerip": {"required": False, "type": "str"},
"peervd": {"required": False, "type": "str"},
"session_sync_filter": {"required": False, "type": "dict",
"options": {
"custom_service": {"required": False, "type": "list",
"options": {
"dst_port_range": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"src_port_range": {"required": False, "type": "str"}
}},
"dstaddr": {"required": False, "type": "str"},
"dstaddr6": {"required": False, "type": "str"},
"dstintf": {"required": False, "type": "str"},
"srcaddr": {"required": False, "type": "str"},
"srcaddr6": {"required": False, "type": "str"},
"srcintf": {"required": False, "type": "str"}
}},
"slave_add_ike_routes": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"sync_id": {"required": False, "type": "int"},
"syncvd": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"wanopt_content_delivery_network_rule": {
"required": False, "type": "dict", "default": None,
"options": {
"category": {"required": False, "type": "str",
"choices": ["vcache", "youtube"]},
"comment": {"required": False, "type": "str"},
"host_domain_name_suffix": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"name": {"required": True, "type": "str"},
"request_cache_control": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"response_cache_control": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"response_expires": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"rules": {"required": False, "type": "list",
"options": {
"content_id": {"required": False, "type": "dict",
"options": {
"end_direction": {"required": False, "type": "str",
"choices": ["forward", "backward"]},
"end_skip": {"required": False, "type": "int"},
"end_str": {"required": False, "type": "str"},
"range_str": {"required": False, "type": "str"},
"start_direction": {"required": False, "type": "str",
"choices": ["forward", "backward"]},
"start_skip": {"required": False, "type": "int"},
"start_str": {"required": False, "type": "str"},
"target": {"required": False, "type": "str",
"choices": ["path", "parameter", "referrer",
"youtube-map", "youtube-id", "youku-id",
"hls-manifest", "dash-manifest", "hls-fragment",
"dash-fragment"]}
}},
"match_entries": {"required": False, "type": "list",
"options": {
"id": {"required": True, "type": "int"},
"pattern": {"required": False, "type": "list",
"options": {
"string": {"required": True, "type": "str"}
}},
"target": {"required": False, "type": "str",
"choices": ["path", "parameter", "referrer",
"youtube-map", "youtube-id", "youku-id"]}
}},
"match_mode": {"required": False, "type": "str",
"choices": ["all", "any"]},
"name": {"required": True, "type": "str"},
"skip_entries": {"required": False, "type": "list",
"options": {
"id": {"required": True, "type": "int"},
"pattern": {"required": False, "type": "list",
"options": {
"string": {"required": True, "type": "str"}
}},
"target": {"required": False, "type": "str",
"choices": ["path", "parameter", "referrer",
"youtube-map", "youtube-id", "youku-id"]}
}},
"skip_rule_mode": {"required": False, "type": "str",
"choices": ["all", "any"]}
}},
"status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"text_response_vcache": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"updateserver": {"required": False, "type": "str",
"choices": ["enable", "disable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wanopt(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wanopt(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"web_proxy_profile": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"header_client_ip": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_front_end_https": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_via_request": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_via_response": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_x_authenticated_groups": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_x_authenticated_user": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"header_x_forwarded_for": {
"required": False,
"type": "str",
"choices": ["pass", "add", "remove"]
},
"headers": {
"required": False,
"type": "list",
"options": {
"action": {
"required":
False,
"type":
"str",
"choices": [
"add-to-request", "add-to-response",
"remove-from-request", "remove-from-response"
]
},
"content": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"name": {
"required": False,
"type": "str"
}
}
},
"log_header_change": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"name": {
"required": True,
"type": "str"
},
"strip_encoding": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_web_proxy(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_web_proxy(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"wireless_controller_global": {
"required": False, "type": "dict", "default": None,
"options": {
"ap_log_server": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ap_log_server_ip": {"required": False, "type": "str"},
"ap_log_server_port": {"required": False, "type": "int"},
"control_message_offload": {"required": False, "type": "str",
"choices": ["ebp-frame", "aeroscout-tag", "ap-list",
"sta-list", "sta-cap-list", "stats",
"aeroscout-mu"]},
"data_ethernet_II": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"discovery_mc_addr": {"required": False, "type": "str"},
"fiapp_eth_type": {"required": False, "type": "int"},
"image_download": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ipsec_base_ip": {"required": False, "type": "str"},
"link_aggregation": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"location": {"required": False, "type": "str"},
"max_clients": {"required": False, "type": "int"},
"max_retransmit": {"required": False, "type": "int"},
"mesh_eth_type": {"required": False, "type": "int"},
"name": {"required": False, "type": "str"},
"rogue_scan_mac_adjacency": {"required": False, "type": "int"},
"wtp_share": {"required": False, "type": "str",
"choices": ["enable", "disable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wireless_controller(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wireless_controller(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"wireless_controller_hotspot20_anqp_nai_realm": {
"required": False, "type": "dict", "default": None,
"options": {
"nai_list": {"required": False, "type": "list",
"options": {
"eap_method": {"required": False, "type": "list",
"options": {
"auth_param": {"required": False, "type": "str",
"options": {
"id": {"required": False, "type": "str",
"choices": ["non-eap-inner-auth", "inner-auth-eap", "credential",
"tunneled-credential"]},
"index": {"required": True, "type": "int"},
"val": {"required": False, "type": "str",
"choices": ["eap-identity", "eap-md5", "eap-tls",
"eap-ttls", "eap-peap", "eap-sim",
"eap-aka", "eap-aka-prime", "non-eap-pap",
"non-eap-chap", "non-eap-mschap", "non-eap-mschapv2",
"cred-sim", "cred-usim", "cred-nfc",
"cred-hardware-token", "cred-softoken", "cred-certificate",
"cred-user-pwd", "cred-none", "cred-vendor-specific",
"tun-cred-sim", "tun-cred-usim", "tun-cred-nfc",
"tun-cred-hardware-token", "tun-cred-softoken",
"tun-cred-certificate", "tun-cred-user-pwd",
"tun-cred-anonymous", "tun-cred-vendor-specific"]}
}},
"index": {"required": True, "type": "int"},
"method": {"required": False, "type": "str",
"choices": ["eap-identity", "eap-md5", "eap-tls",
"eap-ttls", "eap-peap", "eap-sim",
"eap-aka", "eap-aka-prime"]}
}},
"encoding": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"nai_realm": {"required": False, "type": "str"},
"name": {"required": True, "type": "str"}
}},
"name": {"required": True, "type": "str"}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wireless_controller_hotspot20(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wireless_controller_hotspot20(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"system_ddns": {
"required": False, "type": "dict", "default": None,
"options": {
"bound_ip": {"required": False, "type": "str"},
"clear_text": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ddns_auth": {"required": False, "type": "str",
"choices": ["disable", "tsig"]},
"ddns_domain": {"required": False, "type": "str"},
"ddns_key": {"required": False, "type": "str"},
"ddns_keyname": {"required": False, "type": "str"},
"ddns_password": {"required": False, "type": "str"},
"ddns_server": {"required": False, "type": "str",
"choices": ["dyndns.org", "dyns.net", "tzo.com",
"vavic.com", "dipdns.net", "now.net.cn",
"dhs.org", "easydns.com", "genericDDNS",
"FortiGuardDDNS", "noip.com"]},
"ddns_server_ip": {"required": False, "type": "str"},
"ddns_sn": {"required": False, "type": "str"},
"ddns_ttl": {"required": False, "type": "int"},
"ddns_username": {"required": False, "type": "str"},
"ddns_zone": {"required": False, "type": "str"},
"ddnsid": {"required": True, "type": "int"},
"monitor_interface": {"required": False, "type": "list",
"options": {
"interface_name": {"required": False, "type": "str"}
}},
"ssl_certificate": {"required": False, "type": "str"},
"update_interval": {"required": False, "type": "int"},
"use_public_ip": {"required": False, "type": "str",
"choices": ["disable", "enable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"firewall_ssl_server": {
"required": False, "type": "dict", "default": None,
"options": {
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"add_header_x_forwarded_proto": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ip": {"required": False, "type": "str"},
"mapped_port": {"required": False, "type": "int"},
"name": {"required": True, "type": "str"},
"port": {"required": False, "type": "int"},
"ssl_algorithm": {"required": False, "type": "str",
"choices": ["high", "medium", "low"]},
"ssl_cert": {"required": False, "type": "str"},
"ssl_client_renegotiation": {"required": False, "type": "str",
"choices": ["allow", "deny", "secure"]},
"ssl_dh_bits": {"required": False, "type": "str",
"choices": ["768", "1024", "1536",
"2048"]},
"ssl_max_version": {"required": False, "type": "str",
"choices": ["tls-1.0", "tls-1.1", "tls-1.2"]},
"ssl_min_version": {"required": False, "type": "str",
"choices": ["tls-1.0", "tls-1.1", "tls-1.2"]},
"ssl_mode": {"required": False, "type": "str",
"choices": ["half", "full"]},
"ssl_send_empty_frags": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"url_rewrite": {"required": False, "type": "str",
"choices": ["enable", "disable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_firewall(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_firewall(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": True,
"type": "str",
"choices": ["present", "absent"]
},
"wireless_controller_wtp_group": {
"required": False,
"type": "dict",
"default": None,
"options": {
"name": {
"required": True,
"type": "str"
},
"platform_type": {
"required":
False,
"type":
"str",
"choices": [
"AP-11N", "220B", "210B", "222B", "112B", "320B",
"11C", "14C", "223B", "28C", "320C", "221C", "25D",
"222C", "224D", "214B", "21D", "24D", "112D", "223C",
"321C", "C220C", "C225C", "C23JD", "C24JE", "S321C",
"S322C", "S323C", "S311C", "S313C", "S321CR", "S322CR",
"S323CR", "S421E", "S422E", "S423E", "421E", "423E",
"221E", "222E", "223E", "224E", "S221E", "S223E",
"U421E", "U422EV", "U423E", "U221EV", "U223EV",
"U24JEV", "U321EV", "U323EV"
]
},
"wtps": {
"required": False,
"type": "list",
"options": {
"wtp_id": {
"required": False,
"type": "str"
}
}
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wireless_controller(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wireless_controller(
module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"report_chart": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"background": {
"required": False,
"type": "str"
},
"category": {
"required":
False,
"type":
"str",
"choices": [
"misc", "traffic", "event", "virus", "webfilter",
"attack", "spam", "dlp", "app-ctrl", "vulnerability"
]
},
"category_series": {
"required": False,
"type": "dict",
"options": {
"databind": {
"required": False,
"type": "str"
},
"font_size": {
"required": False,
"type": "int"
}
}
},
"color_palette": {
"required": False,
"type": "str"
},
"column": {
"required": False,
"type": "list",
"options": {
"detail_unit": {
"required": False,
"type": "str"
},
"detail_value": {
"required": False,
"type": "str"
},
"footer_unit": {
"required": False,
"type": "str"
},
"footer_value": {
"required": False,
"type": "str"
},
"header_value": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"mapping": {
"required": False,
"type": "list",
"options": {
"displayname": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"op": {
"required":
False,
"type":
"str",
"choices": [
"none", "greater", "greater-equal",
"less", "less-equal", "equal",
"between"
]
},
"value_type": {
"required": False,
"type": "str",
"choices": ["integer", "string"]
},
"value1": {
"required": False,
"type": "str"
},
"value2": {
"required": False,
"type": "str"
}
}
}
}
},
"comments": {
"required": False,
"type": "str"
},
"dataset": {
"required": False,
"type": "str"
},
"dimension": {
"required": False,
"type": "str",
"choices": ["2D", "3D"]
},
"drill_down_charts": {
"required": False,
"type": "list",
"options": {
"chart_name": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
},
"favorite": {
"required": False,
"type": "str",
"choices": ["no", "yes"]
},
"graph_type": {
"required": False,
"type": "str",
"choices": ["none", "bar", "pie", "line", "flow"]
},
"legend": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"legend_font_size": {
"required": False,
"type": "int"
},
"name": {
"required": True,
"type": "str"
},
"period": {
"required": False,
"type": "str",
"choices": ["last24h", "last7d"]
},
"policy": {
"required": False,
"type": "int"
},
"style": {
"required": False,
"type": "str",
"choices": ["auto", "manual"]
},
"title": {
"required": False,
"type": "str"
},
"title_font_size": {
"required": False,
"type": "int"
},
"type": {
"required": False,
"type": "str",
"choices": ["graph", "table"]
},
"value_series": {
"required": False,
"type": "dict",
"options": {
"databind": {
"required": False,
"type": "str"
}
}
},
"x_series": {
"required": False,
"type": "dict",
"options": {
"caption": {
"required": False,
"type": "str"
},
"caption_font_size": {
"required": False,
"type": "int"
},
"databind": {
"required": False,
"type": "str"
},
"font_size": {
"required": False,
"type": "int"
},
"is_category": {
"required": False,
"type": "str",
"choices": ["yes", "no"]
},
"label_angle": {
"required": False,
"type": "str",
"choices": ["45-degree", "vertical", "horizontal"]
},
"scale_direction": {
"required": False,
"type": "str",
"choices": ["decrease", "increase"]
},
"scale_format": {
"required":
False,
"type":
"str",
"choices": [
"YYYY-MM-DD-HH-MM", "YYYY-MM-DD HH",
"YYYY-MM-DD", "YYYY-MM", "YYYY", "HH-MM",
"MM-DD"
]
},
"scale_step": {
"required": False,
"type": "int"
},
"scale_unit": {
"required": False,
"type": "str",
"choices":
["minute", "hour", "day", "month", "year"]
},
"unit": {
"required": False,
"type": "str"
}
}
},
"y_series": {
"required": False,
"type": "dict",
"options": {
"caption": {
"required": False,
"type": "str"
},
"caption_font_size": {
"required": False,
"type": "int"
},
"databind": {
"required": False,
"type": "str"
},
"extra_databind": {
"required": False,
"type": "str"
},
"extra_y": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"extra_y_legend": {
"required": False,
"type": "str"
},
"font_size": {
"required": False,
"type": "int"
},
"group": {
"required": False,
"type": "str"
},
"label_angle": {
"required": False,
"type": "str",
"choices": ["45-degree", "vertical", "horizontal"]
},
"unit": {
"required": False,
"type": "str"
},
"y_legend": {
"required": False,
"type": "str"
}
}
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_report(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_report(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"wanopt_cache_service": {
"required": False, "type": "dict", "default": None,
"options": {
"acceptable_connections": {"required": False, "type": "str",
"choices": ["any", "peers"]},
"collaboration": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"device_id": {"required": False, "type": "str"},
"dst_peer": {"required": False, "type": "list",
"options": {
"auth_type": {"required": False, "type": "int"},
"device_id": {"required": False, "type": "str"},
"encode_type": {"required": False, "type": "int"},
"ip": {"required": False, "type": "str"},
"priority": {"required": False, "type": "int"}
}},
"prefer_scenario": {"required": False, "type": "str",
"choices": ["balance", "prefer-speed", "prefer-cache"]},
"src_peer": {"required": False, "type": "list",
"options": {
"auth_type": {"required": False, "type": "int"},
"device_id": {"required": False, "type": "str"},
"encode_type": {"required": False, "type": "int"},
"ip": {"required": False, "type": "str"},
"priority": {"required": False, "type": "int"}
}}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wanopt(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wanopt(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": True,
"type": "str",
"choices": ["present", "absent"]
},
"vpn_ssl_web_host_check_software": {
"required": False,
"type": "dict",
"default": None,
"options": {
"check_item_list": {
"required": False,
"type": "list",
"options": {
"action": {
"required": False,
"type": "str",
"choices": ["require", "deny"]
},
"id": {
"required": True,
"type": "int"
},
"md5s": {
"required": False,
"type": "list",
"options": {
"id": {
"required": True,
"type": "str"
}
}
},
"target": {
"required": False,
"type": "str"
},
"type": {
"required": False,
"type": "str",
"choices": ["file", "registry", "process"]
},
"version": {
"required": False,
"type": "str"
}
}
},
"guid": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"os_type": {
"required": False,
"type": "str",
"choices": ["windows", "macos"]
},
"type": {
"required": False,
"type": "str",
"choices": ["av", "fw"]
},
"version": {
"required": False,
"type": "str"
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_vpn_ssl_web(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_vpn_ssl_web(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"vpn_ipsec_manualkey": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"authentication": {
"required":
False,
"type":
"str",
"choices":
["null", "md5", "sha1", "sha256", "sha384", "sha512"]
},
"authkey": {
"required": False,
"type": "str"
},
"enckey": {
"required": False,
"type": "str"
},
"encryption": {
"required": False,
"type": "str",
"choices": ["null", "des"]
},
"interface": {
"required": False,
"type": "str"
},
"local_gw": {
"required": False,
"type": "str"
},
"localspi": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"remote_gw": {
"required": False,
"type": "str"
},
"remotespi": {
"required": False,
"type": "str"
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_vpn_ipsec(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_vpn_ipsec(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"webfilter_urlfilter": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"comment": {
"required": False,
"type": "str"
},
"entries": {
"required": False,
"type": "list",
"options": {
"action": {
"required": False,
"type": "str",
"choices": ["exempt", "block", "allow", "monitor"]
},
"dns_address_family": {
"required": False,
"type": "str",
"choices": ["ipv4", "ipv6", "both"]
},
"exempt": {
"required":
False,
"type":
"str",
"choices": [
"av", "web-content", "activex-java-cookie",
"dlp", "fortiguard", "range-block", "pass",
"all"
]
},
"id": {
"required": True,
"type": "int"
},
"referrer_host": {
"required": False,
"type": "str"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"type": {
"required": False,
"type": "str",
"choices": ["simple", "regex", "wildcard"]
},
"url": {
"required": False,
"type": "str"
},
"web_proxy_profile": {
"required": False,
"type": "str"
}
}
},
"id": {
"required": True,
"type": "int"
},
"ip_addr_block": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"name": {
"required": False,
"type": "str"
},
"one_arm_ips_urlfilter": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_webfilter(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_webfilter(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": True,
"type": "str",
"choices": ["present", "absent"]
},
"switch_controller_security_policy_802_1X": {
"required": False,
"type": "dict",
"default": None,
"options": {
"auth_fail_vlan": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"auth_fail_vlan_id": {
"required": False,
"type": "str"
},
"auth_fail_vlanid": {
"required": False,
"type": "int"
},
"eap_passthru": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"guest_auth_delay": {
"required": False,
"type": "int"
},
"guest_vlan": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"guest_vlan_id": {
"required": False,
"type": "str"
},
"guest_vlanid": {
"required": False,
"type": "int"
},
"mac_auth_bypass": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"name": {
"required": True,
"type": "str"
},
"open_auth": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"policy_type": {
"required": False,
"type": "str",
"choices": ["802.1X"]
},
"radius_timeout_overwrite": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"security_mode": {
"required": False,
"type": "str",
"choices": ["802.1X", "802.1X-mac-based"]
},
"user_group": {
"required": False,
"type": "list",
"options": {
"name": {
"required": True,
"type": "str"
}
}
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_switch_controller_security_policy(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_switch_controller_security_policy(
module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"system_netflow": {
"required": False,
"type": "dict",
"default": None,
"options": {
"active_flow_timeout": {
"required": False,
"type": "int"
},
"collector_ip": {
"required": False,
"type": "str"
},
"collector_port": {
"required": False,
"type": "int"
},
"inactive_flow_timeout": {
"required": False,
"type": "int"
},
"source_ip": {
"required": False,
"type": "str"
},
"template_tx_counter": {
"required": False,
"type": "int"
},
"template_tx_timeout": {
"required": False,
"type": "int"
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"system_api_user": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"accprofile": {
"required": False,
"type": "str"
},
"api_key": {
"required": False,
"type": "str"
},
"comments": {
"required": False,
"type": "str"
},
"cors_allow_origin": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"peer_auth": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"peer_group": {
"required": False,
"type": "str"
},
"schedule": {
"required": False,
"type": "str"
},
"trusthost": {
"required": False,
"type": "list",
"options": {
"id": {
"required": True,
"type": "int"
},
"ipv4_trusthost": {
"required": False,
"type": "str"
},
"ipv6_trusthost": {
"required": False,
"type": "str"
},
"type": {
"required": False,
"type": "str",
"choices": ["ipv4-trusthost", "ipv6-trusthost"]
}
}
},
"vdom": {
"required": False,
"type": "list",
"options": {
"name": {
"required": True,
"type": "str"
}
}
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": True,
"type": "str",
"choices": ["present", "absent"]
},
"system_automation_trigger": {
"required": False,
"type": "dict",
"default": None,
"options": {
"event_type": {
"required":
False,
"type":
"str",
"choices": [
"ioc", "event-log", "reboot", "low-memory", "high-cpu",
"license-near-expiry", "ha-failover", "config-change",
"security-rating-summary", "virus-ips-db-updated"
]
},
"ioc_level": {
"required": False,
"type": "str",
"choices": ["medium", "high"]
},
"license_type": {
"required":
False,
"type":
"str",
"choices": [
"forticare-support", "fortiguard-webfilter",
"fortiguard-antispam", "fortiguard-antivirus",
"fortiguard-ips", "fortiguard-management", "forticloud"
]
},
"logid": {
"required": False,
"type": "int"
},
"name": {
"required": True,
"type": "str"
},
"trigger_day": {
"required": False,
"type": "int"
},
"trigger_frequency": {
"required": False,
"type": "str",
"choices": ["hourly", "daily", "weekly", "monthly"]
},
"trigger_hour": {
"required": False,
"type": "int"
},
"trigger_minute": {
"required": False,
"type": "int"
},
"trigger_type": {
"required": False,
"type": "str",
"choices": ["event-based", "scheduled"]
},
"trigger_weekday": {
"required":
False,
"type":
"str",
"choices": [
"sunday", "monday", "tuesday", "wednesday", "thursday",
"friday", "saturday"
]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"web_proxy_forward_server": {
"required": False, "type": "dict", "default": None,
"options": {
"addr_type": {"required": False, "type": "str",
"choices": ["ip", "fqdn"]},
"comment": {"required": False, "type": "str"},
"fqdn": {"required": False, "type": "str"},
"healthcheck": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ip": {"required": False, "type": "str"},
"monitor": {"required": False, "type": "str"},
"name": {"required": True, "type": "str"},
"port": {"required": False, "type": "int"},
"server_down_option": {"required": False, "type": "str",
"choices": ["block", "pass"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_web_proxy(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_web_proxy(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"log_syslogd_override_filter": {
"required": False, "type": "dict", "default": None,
"options": {
"anomaly": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"dns": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"filter": {"required": False, "type": "str"},
"filter_type": {"required": False, "type": "str",
"choices": ["include", "exclude"]},
"forward_traffic": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"gtp": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"local_traffic": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"multicast_traffic": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"netscan_discovery": {"required": False, "type": "str"},
"netscan_vulnerability": {"required": False, "type": "str"},
"severity": {"required": False, "type": "str",
"choices": ["emergency", "alert", "critical",
"error", "warning", "notification",
"information", "debug"]},
"sniffer_traffic": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ssh": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"voip": {"required": False, "type": "str",
"choices": ["enable", "disable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_log_syslogd(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_log_syslogd(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"firewall_multicast_policy": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"action": {
"required": False,
"type": "str",
"choices": ["accept", "deny"]
},
"dnat": {
"required": False,
"type": "str"
},
"dstaddr": {
"required": False,
"type": "list",
"options": {
"name": {
"required": True,
"type": "str"
}
}
},
"dstintf": {
"required": False,
"type": "str"
},
"end_port": {
"required": False,
"type": "int"
},
"id": {
"required": True,
"type": "int"
},
"logtraffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"protocol": {
"required": False,
"type": "int"
},
"snat": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"snat_ip": {
"required": False,
"type": "str"
},
"srcaddr": {
"required": False,
"type": "list",
"options": {
"name": {
"required": True,
"type": "str"
}
}
},
"srcintf": {
"required": False,
"type": "str"
},
"start_port": {
"required": False,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_firewall(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_firewall(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"system_vxlan": {
"required": False, "type": "dict", "default": None,
"options": {
"dstport": {"required": False, "type": "int"},
"interface": {"required": False, "type": "str"},
"ip_version": {"required": False, "type": "str",
"choices": ["ipv4-unicast", "ipv6-unicast", "ipv4-multicast",
"ipv6-multicast"]},
"multicast_ttl": {"required": False, "type": "int"},
"name": {"required": True, "type": "str"},
"remote_ip": {"required": False, "type": "list",
"options": {
"ip": {"required": True, "type": "str"}
}},
"remote_ip6": {"required": False, "type": "list",
"options": {
"ip6": {"required": True, "type": "str"}
}},
"vni": {"required": False, "type": "int"}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_system(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_system(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"switch_controller_lldp_settings": {
"required": False,
"type": "dict",
"default": None,
"options": {
"fast_start_interval": {
"required": False,
"type": "int"
},
"management_interface": {
"required": False,
"type": "str",
"choices": ["internal", "mgmt"]
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tx_hold": {
"required": False,
"type": "int"
},
"tx_interval": {
"required": False,
"type": "int"
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_switch_controller(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_switch_controller(
module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"firewall_ssh_local_key": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"name": {
"required": True,
"type": "str"
},
"password": {
"required": False,
"type": "str"
},
"private_key": {
"required": False,
"type": "str"
},
"public_key": {
"required": False,
"type": "str"
},
"source": {
"required": False,
"type": "str",
"choices": ["built-in", "user"]
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_firewall_ssh(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_firewall_ssh(
module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
def main():
fields = {
"host": {"required": False, "type": "str"},
"username": {"required": False, "type": "str"},
"password": {"required": False, "type": "str", "default": "", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssl_verify": {"required": False, "type": "bool", "default": True},
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"firewall_interface_policy6": {
"required": False, "type": "dict", "default": None,
"options": {
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"address_type": {"required": False, "type": "str",
"choices": ["ipv4", "ipv6"]},
"application_list": {"required": False, "type": "str"},
"application_list_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"av_profile": {"required": False, "type": "str"},
"av_profile_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"comments": {"required": False, "type": "str"},
"dlp_sensor": {"required": False, "type": "str"},
"dlp_sensor_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"dsri": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"dstaddr6": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"interface": {"required": False, "type": "str"},
"ips_sensor": {"required": False, "type": "str"},
"ips_sensor_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"label": {"required": False, "type": "str"},
"logtraffic": {"required": False, "type": "str",
"choices": ["all", "utm", "disable"]},
"policyid": {"required": True, "type": "int"},
"scan_botnet_connections": {"required": False, "type": "str",
"choices": ["disable", "block", "monitor"]},
"service6": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"spamfilter_profile": {"required": False, "type": "str"},
"spamfilter_profile_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"srcaddr6": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"webfilter_profile": {"required": False, "type": "str"},
"webfilter_profile_status": {"required": False, "type": "str",
"choices": ["enable", "disable"]}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_firewall(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_firewall(module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
try:
from ansible_collections.misc.not_a_real_collection.plugins.modules import fortios_log_threat_weight
except ImportError:
pytest.skip("Could not load required modules for testing",
allow_module_level=True)
@pytest.fixture(autouse=True)
def connection_mock(mocker):
connection_class_mock = mocker.patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.fortios_log_threat_weight.Connection'
)
return connection_class_mock
fos_instance = FortiOSHandler(connection_mock)
def test_log_threat_weight_creation(mocker):
schema_method_mock = mocker.patch(
'ansible_collections.misc.not_a_real_collection.plugins.module_utils.network.fortios.fortios.FortiOSHandler.schema'
)
set_method_result = {
'status': 'success',
'http_method': 'POST',
'http_status': 200
}
set_method_mock = mocker.patch(
'ansible_collections.misc.not_a_real_collection.plugins.module_utils.network.fortios.fortios.FortiOSHandler.set',
return_value=set_method_result)
def main():
fields = {
"host": {
"required": False,
"type": "str"
},
"username": {
"required": False,
"type": "str"
},
"password": {
"required": False,
"type": "str",
"default": "",
"no_log": True
},
"vdom": {
"required": False,
"type": "str",
"default": "root"
},
"https": {
"required": False,
"type": "bool",
"default": True
},
"ssl_verify": {
"required": False,
"type": "bool",
"default": True
},
"state": {
"required": True,
"type": "str",
"choices": ["present", "absent"]
},
"wireless_controller_hotspot20_h2qp_osu_provider": {
"required": False,
"type": "dict",
"default": None,
"options": {
"friendly_name": {
"required": False,
"type": "list",
"options": {
"friendly_name": {
"required": False,
"type": "str"
},
"index": {
"required": True,
"type": "int"
},
"lang": {
"required": False,
"type": "str"
}
}
},
"icon": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"osu_method": {
"required": False,
"type": "str",
"choices": ["oma-dm", "soap-xml-spp", "reserved"]
},
"osu_nai": {
"required": False,
"type": "str"
},
"server_uri": {
"required": False,
"type": "str"
},
"service_description": {
"required": False,
"type": "list",
"options": {
"lang": {
"required": False,
"type": "str"
},
"service_description": {
"required": False,
"type": "str"
},
"service_id": {
"required": False,
"type": "int"
}
}
}
}
}
}
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
# legacy_mode refers to using fortiosapi instead of HTTPAPI
legacy_mode = 'host' in module.params and module.params['host'] is not None and \
'username' in module.params and module.params['username'] is not None and \
'password' in module.params and module.params['password'] is not None
if not legacy_mode:
if module._socket_path:
connection = Connection(module._socket_path)
fos = FortiOSHandler(connection)
is_error, has_changed, result = fortios_wireless_controller_hotspot20(
module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
else:
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
fos = FortiOSAPI()
login(module.params, fos)
is_error, has_changed, result = fortios_wireless_controller_hotspot20(
module.params, fos)
fos.logout()
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
