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"]},
"router_multicast_flow": {
"required": False, "type": "dict", "default": None,
"options": {
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"comments": {"required": False, "type": "str"},
"flows": {"required": False, "type": "list",
"options": {
"group_addr": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"source_addr": {"required": False, "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_router(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_router(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_fortiguard_override_setting": {
"required": False, "type": "dict", "default": None,
"options": {
"override": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"status": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"upload_day": {"required": False, "type": "str"},
"upload_interval": {"required": False, "type": "str",
"choices": ["daily", "weekly", "monthly"]},
"upload_option": {"required": False, "type": "str",
"choices": ["store-and-upload", "realtime", "1-minute",
"5-minute"]},
"upload_time": {"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_log_fortiguard(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_fortiguard(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_dedicated_mgmt": {
"required": False, "type": "dict", "default": None,
"options": {
"default_gateway": {"required": False, "type": "str"},
"dhcp_end_ip": {"required": False, "type": "str"},
"dhcp_netmask": {"required": False, "type": "str"},
"dhcp_server": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"dhcp_start_ip": {"required": False, "type": "str"},
"interface": {"required": False, "type": "str"},
"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"]},
"wireless_controller_hotspot20_anqp_network_auth_type": {
"required": False, "type": "dict", "default": None,
"options": {
"auth_type": {"required": False, "type": "str",
"choices": ["acceptance-of-terms", "online-enrollment", "http-redirection",
"dns-redirection"]},
"name": {"required": True, "type": "str"},
"url": {"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_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},
"webfilter_ips_urlfilter_cache_setting": {
"required": False, "type": "dict", "default": None,
"options": {
"dns_retry_interval": {"required": False, "type": "int"},
"extended_ttl": {"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_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},
"log_fortiguard_filter": {
"required": False, "type": "dict", "default": None,
"options": {
"anomaly": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"dlp_archive": {"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_fortiguard(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_fortiguard(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_content": {
"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": ["block", "exempt"]
},
"lang": {
"required":
False,
"type":
"str",
"choices": [
"western", "simch", "trach", "japanese",
"korean", "french", "thai", "spanish",
"cyrillic"
]
},
"name": {
"required": True,
"type": "str"
},
"pattern_type": {
"required": False,
"type": "str",
"choices": ["wildcard", "regexp"]
},
"score": {
"required": False,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
}
}
},
"id": {
"required": True,
"type": "int"
},
"name": {
"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_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": False,
"type": "str",
"choices": ["present", "absent"]
},
"wanopt_profile": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"auth_group": {
"required": False,
"type": "str"
},
"cifs": {
"required": False,
"type": "dict",
"options": {
"byte_caching": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"log_traffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"port": {
"required": False,
"type": "int"
},
"prefer_chunking": {
"required": False,
"type": "str",
"choices": ["dynamic", "fix"]
},
"secure_tunnel": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_sharing": {
"required": False,
"type": "str",
"choices": ["private", "shared", "express-shared"]
}
}
},
"comments": {
"required": False,
"type": "str"
},
"ftp": {
"required": False,
"type": "dict",
"options": {
"byte_caching": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"log_traffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"port": {
"required": False,
"type": "int"
},
"prefer_chunking": {
"required": False,
"type": "str",
"choices": ["dynamic", "fix"]
},
"secure_tunnel": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_sharing": {
"required": False,
"type": "str",
"choices": ["private", "shared", "express-shared"]
}
}
},
"http": {
"required": False,
"type": "dict",
"options": {
"byte_caching": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"log_traffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"port": {
"required": False,
"type": "int"
},
"prefer_chunking": {
"required": False,
"type": "str",
"choices": ["dynamic", "fix"]
},
"secure_tunnel": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ssl": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ssl_port": {
"required": False,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_non_http": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_sharing": {
"required": False,
"type": "str",
"choices": ["private", "shared", "express-shared"]
},
"unknown_http_version": {
"required": False,
"type": "str",
"choices": ["reject", "tunnel", "best-effort"]
}
}
},
"mapi": {
"required": False,
"type": "dict",
"options": {
"byte_caching": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"log_traffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"port": {
"required": False,
"type": "int"
},
"secure_tunnel": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_sharing": {
"required": False,
"type": "str",
"choices": ["private", "shared", "express-shared"]
}
}
},
"name": {
"required": True,
"type": "str"
},
"tcp": {
"required": False,
"type": "dict",
"options": {
"byte_caching": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"byte_caching_opt": {
"required": False,
"type": "str",
"choices": ["mem-only", "mem-disk"]
},
"log_traffic": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"port": {
"required": False,
"type": "str"
},
"secure_tunnel": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ssl": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ssl_port": {
"required": False,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"tunnel_sharing": {
"required": False,
"type": "str",
"choices": ["private", "shared", "express-shared"]
}
}
},
"transparent": {
"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": True,
"type": "str",
"choices": ["present", "absent"]
},
"system_vdom_property": {
"required": False,
"type": "dict",
"default": None,
"options": {
"custom_service": {
"required": False,
"type": "str"
},
"description": {
"required": False,
"type": "str"
},
"dialup_tunnel": {
"required": False,
"type": "str"
},
"firewall_address": {
"required": False,
"type": "str"
},
"firewall_addrgrp": {
"required": False,
"type": "str"
},
"firewall_policy": {
"required": False,
"type": "str"
},
"ipsec_phase1": {
"required": False,
"type": "str"
},
"ipsec_phase1_interface": {
"required": False,
"type": "str"
},
"ipsec_phase2": {
"required": False,
"type": "str"
},
"ipsec_phase2_interface": {
"required": False,
"type": "str"
},
"log_disk_quota": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"onetime_schedule": {
"required": False,
"type": "str"
},
"proxy": {
"required": False,
"type": "str"
},
"recurring_schedule": {
"required": False,
"type": "str"
},
"service_group": {
"required": False,
"type": "str"
},
"session": {
"required": False,
"type": "str"
},
"snmp_index": {
"required": False,
"type": "int"
},
"sslvpn": {
"required": False,
"type": "str"
},
"user": {
"required": False,
"type": "str"
},
"user_group": {
"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_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_dhcp_server": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"auto_configuration": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"conflicted_ip_timeout": {
"required": False,
"type": "int"
},
"ddns_auth": {
"required": False,
"type": "str",
"choices": ["disable", "tsig"]
},
"ddns_key": {
"required": False,
"type": "str"
},
"ddns_keyname": {
"required": False,
"type": "str"
},
"ddns_server_ip": {
"required": False,
"type": "str"
},
"ddns_ttl": {
"required": False,
"type": "int"
},
"ddns_update": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"ddns_update_override": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"ddns_zone": {
"required": False,
"type": "str"
},
"default_gateway": {
"required": False,
"type": "str"
},
"dns_server1": {
"required": False,
"type": "str"
},
"dns_server2": {
"required": False,
"type": "str"
},
"dns_server3": {
"required": False,
"type": "str"
},
"dns_service": {
"required": False,
"type": "str",
"choices": ["local", "default", "specify"]
},
"domain": {
"required": False,
"type": "str"
},
"exclude_range": {
"required": False,
"type": "list",
"options": {
"end_ip": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"start_ip": {
"required": False,
"type": "str"
}
}
},
"filename": {
"required": False,
"type": "str"
},
"forticlient_on_net_status": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"id": {
"required": True,
"type": "int"
},
"interface": {
"required": False,
"type": "str"
},
"ip_mode": {
"required": False,
"type": "str",
"choices": ["range", "usrgrp"]
},
"ip_range": {
"required": False,
"type": "list",
"options": {
"end_ip": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"start_ip": {
"required": False,
"type": "str"
}
}
},
"ipsec_lease_hold": {
"required": False,
"type": "int"
},
"lease_time": {
"required": False,
"type": "int"
},
"mac_acl_default_action": {
"required": False,
"type": "str",
"choices": ["assign", "block"]
},
"netmask": {
"required": False,
"type": "str"
},
"next_server": {
"required": False,
"type": "str"
},
"ntp_server1": {
"required": False,
"type": "str"
},
"ntp_server2": {
"required": False,
"type": "str"
},
"ntp_server3": {
"required": False,
"type": "str"
},
"ntp_service": {
"required": False,
"type": "str",
"choices": ["local", "default", "specify"]
},
"options": {
"required": False,
"type": "list",
"options": {
"code": {
"required": False,
"type": "int"
},
"id": {
"required": True,
"type": "int"
},
"ip": {
"required": False,
"type": "str"
},
"type": {
"required": False,
"type": "str",
"choices": ["hex", "string", "ip", "fqdn"]
},
"value": {
"required": False,
"type": "str"
}
}
},
"reserved_address": {
"required": False,
"type": "list",
"options": {
"action": {
"required": False,
"type": "str",
"choices": ["assign", "block", "reserved"]
},
"description": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"ip": {
"required": False,
"type": "str"
},
"mac": {
"required": False,
"type": "str"
}
}
},
"server_type": {
"required": False,
"type": "str",
"choices": ["regular", "ipsec"]
},
"status": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"tftp_server": {
"required": False,
"type": "list",
"options": {
"tftp_server": {
"required": False,
"type": "str"
}
}
},
"timezone": {
"required":
False,
"type":
"str",
"choices": [
"01", "02", "03", "04", "05", "81", "06", "07", "08",
"09", "10", "11", "12", "13", "74", "14", "77", "15",
"87", "16", "17", "18", "19", "20", "75", "21", "22",
"23", "24", "80", "79", "25", "26", "27", "28", "78",
"29", "30", "31", "32", "33", "34", "35", "36", "37",
"38", "83", "84", "40", "85", "41", "42", "43", "39",
"44", "46", "47", "51", "48", "45", "49", "50", "52",
"53", "54", "55", "56", "57", "58", "59", "60", "62",
"63", "61", "64", "65", "66", "67", "68", "69", "70",
"71", "72", "00", "82", "73", "86", "76"
]
},
"timezone_option": {
"required": False,
"type": "str",
"choices": ["disable", "default", "specify"]
},
"vci_match": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"vci_string": {
"required": False,
"type": "list",
"options": {
"vci_string": {
"required": False,
"type": "str"
}
}
},
"wifi_ac1": {
"required": False,
"type": "str"
},
"wifi_ac2": {
"required": False,
"type": "str"
},
"wifi_ac3": {
"required": False,
"type": "str"
},
"wins_server1": {
"required": False,
"type": "str"
},
"wins_server2": {
"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_system_dhcp(
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_dhcp(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_host_key": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"hostname": {
"required": False,
"type": "str"
},
"ip": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"nid": {
"required": False,
"type": "str",
"choices": ["256", "384", "521"]
},
"port": {
"required": False,
"type": "int"
},
"public_key": {
"required": False,
"type": "str"
},
"status": {
"required": False,
"type": "str",
"choices": ["trusted", "revoked"]
},
"type": {
"required":
False,
"type":
"str",
"choices": [
"RSA", "DSA", "ECDSA", "ED25519", "RSA-CA", "DSA-CA",
"ECDSA-CA", "ED25519-CA"
]
}
}
}
}
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"]
},
"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},
"system_management_tunnel": {
"required": False, "type": "dict", "default": None,
"options": {
"allow_collect_statistics": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_config_restore": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_push_configuration": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_push_firmware": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"authorized_manager_only": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"serial_number": {"required": False, "type": "str"},
"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},
"system_central_management": {
"required": False, "type": "dict", "default": None,
"options": {
"allow_monitor": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_push_configuration": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_push_firmware": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"allow_remote_firmware_upgrade": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"enc_algorithm": {"required": False, "type": "str",
"choices": ["default", "high", "low"]},
"fmg": {"required": False, "type": "str"},
"fmg_source_ip": {"required": False, "type": "str"},
"fmg_source_ip6": {"required": False, "type": "str"},
"include_default_servers": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"mode": {"required": False, "type": "str",
"choices": ["normal", "backup"]},
"schedule_config_restore": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"schedule_script_restore": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"serial_number": {"required": False, "type": "str"},
"server_list": {"required": False, "type": "list",
"options": {
"addr_type": {"required": False, "type": "str",
"choices": ["ipv4", "ipv6", "fqdn"]},
"fqdn": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"server_address": {"required": False, "type": "str"},
"server_address6": {"required": False, "type": "str"},
"server_type": {"required": False, "type": "str",
"choices": ["update", "rating"]}
}},
"type": {"required": False, "type": "str",
"choices": ["fortimanager", "fortiguard", "none"]},
"vdom": {"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_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_vip6": {
"required": False, "type": "dict", "default": None,
"options": {
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"arp_reply": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"color": {"required": False, "type": "int"},
"comment": {"required": False, "type": "str"},
"extip": {"required": False, "type": "str"},
"extport": {"required": False, "type": "str"},
"http_cookie_age": {"required": False, "type": "int"},
"http_cookie_domain": {"required": False, "type": "str"},
"http_cookie_domain_from_host": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"http_cookie_generation": {"required": False, "type": "int"},
"http_cookie_path": {"required": False, "type": "str"},
"http_cookie_share": {"required": False, "type": "str",
"choices": ["disable", "same-ip"]},
"http_ip_header": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"http_ip_header_name": {"required": False, "type": "str"},
"http_multiplex": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"https_cookie_secure": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"id": {"required": False, "type": "int"},
"ldb_method": {"required": False, "type": "str",
"choices": ["static", "round-robin", "weighted",
"least-session", "least-rtt", "first-alive",
"http-host"]},
"mappedip": {"required": False, "type": "str"},
"mappedport": {"required": False, "type": "str"},
"max_embryonic_connections": {"required": False, "type": "int"},
"monitor": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"name": {"required": True, "type": "str"},
"outlook_web_access": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"persistence": {"required": False, "type": "str",
"choices": ["none", "http-cookie", "ssl-session-id"]},
"portforward": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"protocol": {"required": False, "type": "str",
"choices": ["tcp", "udp", "sctp"]},
"realservers": {"required": False, "type": "list",
"options": {
"client_ip": {"required": False, "type": "str"},
"healthcheck": {"required": False, "type": "str",
"choices": ["disable", "enable", "vip"]},
"holddown_interval": {"required": False, "type": "int"},
"http_host": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"ip": {"required": False, "type": "str"},
"max_connections": {"required": False, "type": "int"},
"monitor": {"required": False, "type": "str"},
"port": {"required": False, "type": "int"},
"status": {"required": False, "type": "str",
"choices": ["active", "standby", "disable"]},
"weight": {"required": False, "type": "int"}
}},
"server_type": {"required": False, "type": "str",
"choices": ["http", "https", "imaps",
"pop3s", "smtps", "ssl",
"tcp", "udp", "ip"]},
"src_filter": {"required": False, "type": "list",
"options": {
"range": {"required": True, "type": "str"}
}},
"ssl_algorithm": {"required": False, "type": "str",
"choices": ["high", "medium", "low",
"custom"]},
"ssl_certificate": {"required": False, "type": "str"},
"ssl_cipher_suites": {"required": False, "type": "list",
"options": {
"cipher": {"required": False, "type": "str",
"choices": ["TLS-RSA-WITH-3DES-EDE-CBC-SHA", "TLS-DHE-RSA-WITH-DES-CBC-SHA",
"TLS-DHE-DSS-WITH-DES-CBC-SHA"]},
"priority": {"required": True, "type": "int"},
"versions": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2"]}
}},
"ssl_client_fallback": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ssl_client_renegotiation": {"required": False, "type": "str",
"choices": ["allow", "deny", "secure"]},
"ssl_client_session_state_max": {"required": False, "type": "int"},
"ssl_client_session_state_timeout": {"required": False, "type": "int"},
"ssl_client_session_state_type": {"required": False, "type": "str",
"choices": ["disable", "time", "count",
"both"]},
"ssl_dh_bits": {"required": False, "type": "str",
"choices": ["768", "1024", "1536",
"2048", "3072", "4096"]},
"ssl_hpkp": {"required": False, "type": "str",
"choices": ["disable", "enable", "report-only"]},
"ssl_hpkp_age": {"required": False, "type": "int"},
"ssl_hpkp_backup": {"required": False, "type": "str"},
"ssl_hpkp_include_subdomains": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ssl_hpkp_primary": {"required": False, "type": "str"},
"ssl_hpkp_report_uri": {"required": False, "type": "str"},
"ssl_hsts": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ssl_hsts_age": {"required": False, "type": "int"},
"ssl_hsts_include_subdomains": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"ssl_http_location_conversion": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ssl_http_match_host": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ssl_max_version": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2"]},
"ssl_min_version": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2"]},
"ssl_mode": {"required": False, "type": "str",
"choices": ["half", "full"]},
"ssl_pfs": {"required": False, "type": "str",
"choices": ["require", "deny", "allow"]},
"ssl_send_empty_frags": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"ssl_server_algorithm": {"required": False, "type": "str",
"choices": ["high", "medium", "low",
"custom", "client"]},
"ssl_server_cipher_suites": {"required": False, "type": "list",
"options": {
"cipher": {"required": False, "type": "str",
"choices": ["TLS-RSA-WITH-3DES-EDE-CBC-SHA", "TLS-DHE-RSA-WITH-DES-CBC-SHA",
"TLS-DHE-DSS-WITH-DES-CBC-SHA"]},
"priority": {"required": True, "type": "int"},
"versions": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2"]}
}},
"ssl_server_max_version": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2", "client"]},
"ssl_server_min_version": {"required": False, "type": "str",
"choices": ["ssl-3.0", "tls-1.0", "tls-1.1",
"tls-1.2", "client"]},
"ssl_server_session_state_max": {"required": False, "type": "int"},
"ssl_server_session_state_timeout": {"required": False, "type": "int"},
"ssl_server_session_state_type": {"required": False, "type": "str",
"choices": ["disable", "time", "count",
"both"]},
"type": {"required": False, "type": "str",
"choices": ["static-nat", "server-load-balance"]},
"uuid": {"required": False, "type": "str"},
"weblogic_server": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"websphere_server": {"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_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": False,
"type": "str",
"choices": ["present", "absent"]
},
"system_accprofile": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"admintimeout": {
"required": False,
"type": "int"
},
"admintimeout_override": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"authgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"comments": {
"required": False,
"type": "str"
},
"ftviewgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"fwgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write", "custom"]
},
"fwgrp_permission": {
"required": False,
"type": "dict",
"options": {
"address": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"policy": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"schedule": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"service": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
},
"loggrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write", "custom"]
},
"loggrp_permission": {
"required": False,
"type": "dict",
"options": {
"config": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"data_access": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"report_access": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"threat_weight": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
},
"name": {
"required": True,
"type": "str"
},
"netgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write", "custom"]
},
"netgrp_permission": {
"required": False,
"type": "dict",
"options": {
"cfg": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"packet_capture": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"route_cfg": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
},
"scope": {
"required": False,
"type": "str",
"choices": ["vdom", "global"]
},
"secfabgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"sysgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write", "custom"]
},
"sysgrp_permission": {
"required": False,
"type": "dict",
"options": {
"admin": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"cfg": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"mnt": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"upd": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
},
"utmgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write", "custom"]
},
"utmgrp_permission": {
"required": False,
"type": "dict",
"options": {
"antivirus": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"application_control": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"data_loss_prevention": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"dnsfilter": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"endpoint_control": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"icap": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"ips": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"spamfilter": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"voip": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"waf": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"webfilter": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
},
"vpngrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"wanoptgrp": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
},
"wifi": {
"required": False,
"type": "str",
"choices": ["none", "read", "read-write"]
}
}
}
}
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
},
"log_syslogd_setting": {
"required": False,
"type": "dict",
"default": None,
"options": {
"certificate": {
"required": False,
"type": "str"
},
"custom_field_name": {
"required": False,
"type": "list",
"options": {
"custom": {
"required": False,
"type": "str"
},
"id": {
"required": True,
"type": "int"
},
"name": {
"required": False,
"type": "str"
}
}
},
"enc_algorithm": {
"required": False,
"type": "str",
"choices": ["high-medium", "high", "low", "disable"]
},
"facility": {
"required":
False,
"type":
"str",
"choices": [
"kernel", "user", "mail", "daemon", "auth", "syslog",
"lpr", "news", "uucp", "cron", "authpriv", "ftp",
"ntp", "audit", "alert", "clock", "local0", "local1",
"local2", "local3", "local4", "local5", "local6",
"local7"
]
},
"format": {
"required": False,
"type": "str",
"choices": ["default", "csv", "cef"]
},
"mode": {
"required": False,
"type": "str",
"choices": ["udp", "legacy-reliable", "reliable"]
},
"port": {
"required": False,
"type": "int"
},
"server": {
"required": False,
"type": "str"
},
"source_ip": {
"required": False,
"type": "str"
},
"ssl_min_proto_version": {
"required": False,
"type": "str",
"choices":
["default", "SSLv3", "TLSv1", "TLSv1-1", "TLSv1-2"]
},
"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_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_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"]},
"system_dhcp6_server": {
"required": False, "type": "dict", "default": None,
"options": {
"dns_search_list": {"required": False, "type": "str",
"choices": ["delegated", "specify"]},
"dns_server1": {"required": False, "type": "str"},
"dns_server2": {"required": False, "type": "str"},
"dns_server3": {"required": False, "type": "str"},
"dns_service": {"required": False, "type": "str",
"choices": ["delegated", "default", "specify"]},
"domain": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"interface": {"required": False, "type": "str"},
"ip_mode": {"required": False, "type": "str",
"choices": ["range", "delegated"]},
"ip_range": {"required": False, "type": "list",
"options": {
"end_ip": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"start_ip": {"required": False, "type": "str"}
}},
"lease_time": {"required": False, "type": "int"},
"option1": {"required": False, "type": "str"},
"option2": {"required": False, "type": "str"},
"option3": {"required": False, "type": "str"},
"prefix_range": {"required": False, "type": "list",
"options": {
"end_prefix": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"},
"prefix_length": {"required": False, "type": "int"},
"start_prefix": {"required": False, "type": "str"}
}},
"rapid_commit": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"status": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"subnet": {"required": False, "type": "str"},
"upstream_interface": {"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_system_dhcp6(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_dhcp6(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_policy": {
"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"]
},
"dstaddr": {
"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"]
},
"service": {
"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"]
},
"srcaddr": {
"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)
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_global": {
"required": False, "type": "dict", "default": None,
"options": {
"allow_multiple_interfaces": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"default_virtual_switch_vlan": {"required": False, "type": "str"},
"disable_discovery": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}},
"https_image_push": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"log_mac_limit_violations": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"mac_aging_interval": {"required": False, "type": "int"},
"mac_retention_period": {"required": False, "type": "int"},
"mac_violation_timer": {"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"]
},
"switch_controller_lldp_profile": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"802.1_tlvs": {
"required": False,
"type": "str",
"choices": ["port-vlan-id"]
},
"802.3_tlvs": {
"required": False,
"type": "str",
"choices": ["max-frame-size"]
},
"auto_isl": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"auto_isl_hello_timer": {
"required": False,
"type": "int"
},
"auto_isl_port_group": {
"required": False,
"type": "int"
},
"auto_isl_receive_timeout": {
"required": False,
"type": "int"
},
"custom_tlvs": {
"required": False,
"type": "list",
"options": {
"information_string": {
"required": False,
"type": "str"
},
"name": {
"required": True,
"type": "str"
},
"oui": {
"required": False,
"type": "str"
},
"subtype": {
"required": False,
"type": "int"
}
}
},
"med_network_policy": {
"required": False,
"type": "list",
"options": {
"dscp": {
"required": False,
"type": "int"
},
"name": {
"required": True,
"type": "str"
},
"priority": {
"required": False,
"type": "int"
},
"status": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"vlan": {
"required": False,
"type": "int"
}
}
},
"med_tlvs": {
"required": False,
"type": "str",
"choices": ["inventory-management", "network-policy"]
},
"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(
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_internet_service": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"database": {
"required": False,
"type": "str",
"choices": ["isdb", "irdb"]
},
"direction": {
"required": False,
"type": "str",
"choices": ["src", "dst", "both"]
},
"entry": {
"required": False,
"type": "list",
"options": {
"id": {
"required": True,
"type": "int"
},
"ip_number": {
"required": False,
"type": "int"
},
"ip_range_number": {
"required": False,
"type": "int"
},
"port": {
"required": False,
"type": "int"
},
"protocol": {
"required": False,
"type": "int"
}
}
},
"icon_id": {
"required": False,
"type": "int"
},
"id": {
"required": True,
"type": "int"
},
"name": {
"required": False,
"type": "str"
},
"offset": {
"required": False,
"type": "int"
},
"reputation": {
"required": False,
"type": "int"
},
"sld_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_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": False, "type": "str",
"choices": ["present", "absent"]},
"firewall_proxy_address": {
"required": False, "type": "dict", "default": None,
"options": {
"state": {"required": False, "type": "str",
"choices": ["present", "absent"]},
"case_sensitivity": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"category": {"required": False, "type": "list",
"options": {
"id": {"required": True, "type": "int"}
}},
"color": {"required": False, "type": "int"},
"comment": {"required": False, "type": "str"},
"header": {"required": False, "type": "str"},
"header_group": {"required": False, "type": "list",
"options": {
"case_sensitivity": {"required": False, "type": "str",
"choices": ["disable", "enable"]},
"header": {"required": False, "type": "str"},
"header_name": {"required": False, "type": "str"},
"id": {"required": True, "type": "int"}
}},
"header_name": {"required": False, "type": "str"},
"host": {"required": False, "type": "str"},
"host_regex": {"required": False, "type": "str"},
"method": {"required": False, "type": "str",
"choices": ["get", "post", "put",
"head", "connect", "trace",
"options", "delete"]},
"name": {"required": True, "type": "str"},
"path": {"required": False, "type": "str"},
"query": {"required": False, "type": "str"},
"referrer": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"tagging": {"required": False, "type": "list",
"options": {
"category": {"required": False, "type": "str"},
"name": {"required": True, "type": "str"},
"tags": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"}
}}
}},
"type": {"required": False, "type": "str",
"choices": ["host-regex", "url", "category",
"method", "ua", "header",
"src-advanced", "dst-advanced"]},
"ua": {"required": False, "type": "str",
"choices": ["chrome", "ms", "firefox",
"safari", "other"]},
"uuid": {"required": False, "type": "str"},
"visibility": {"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": False,
"type": "str",
"choices": ["present", "absent"]
},
"wireless_controller_wids_profile": {
"required": False,
"type": "dict",
"default": None,
"options": {
"state": {
"required": False,
"type": "str",
"choices": ["present", "absent"]
},
"ap_auto_suppress": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ap_bgscan_disable_day": {
"required":
False,
"type":
"str",
"choices": [
"sunday", "monday", "tuesday", "wednesday", "thursday",
"friday", "saturday"
]
},
"ap_bgscan_disable_end": {
"required": False,
"type": "str"
},
"ap_bgscan_disable_start": {
"required": False,
"type": "str"
},
"ap_bgscan_duration": {
"required": False,
"type": "int"
},
"ap_bgscan_idle": {
"required": False,
"type": "int"
},
"ap_bgscan_intv": {
"required": False,
"type": "int"
},
"ap_bgscan_period": {
"required": False,
"type": "int"
},
"ap_bgscan_report_intv": {
"required": False,
"type": "int"
},
"ap_fgscan_report_intv": {
"required": False,
"type": "int"
},
"ap_scan": {
"required": False,
"type": "str",
"choices": ["disable", "enable"]
},
"ap_scan_passive": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"asleap_attack": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"assoc_flood_thresh": {
"required": False,
"type": "int"
},
"assoc_flood_time": {
"required": False,
"type": "int"
},
"assoc_frame_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"auth_flood_thresh": {
"required": False,
"type": "int"
},
"auth_flood_time": {
"required": False,
"type": "int"
},
"auth_frame_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"comment": {
"required": False,
"type": "str"
},
"deauth_broadcast": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"deauth_unknown_src_thresh": {
"required": False,
"type": "int"
},
"eapol_fail_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_fail_intv": {
"required": False,
"type": "int"
},
"eapol_fail_thresh": {
"required": False,
"type": "int"
},
"eapol_logoff_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_logoff_intv": {
"required": False,
"type": "int"
},
"eapol_logoff_thresh": {
"required": False,
"type": "int"
},
"eapol_pre_fail_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_pre_fail_intv": {
"required": False,
"type": "int"
},
"eapol_pre_fail_thresh": {
"required": False,
"type": "int"
},
"eapol_pre_succ_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_pre_succ_intv": {
"required": False,
"type": "int"
},
"eapol_pre_succ_thresh": {
"required": False,
"type": "int"
},
"eapol_start_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_start_intv": {
"required": False,
"type": "int"
},
"eapol_start_thresh": {
"required": False,
"type": "int"
},
"eapol_succ_flood": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"eapol_succ_intv": {
"required": False,
"type": "int"
},
"eapol_succ_thresh": {
"required": False,
"type": "int"
},
"invalid_mac_oui": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"long_duration_attack": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"long_duration_thresh": {
"required": False,
"type": "int"
},
"name": {
"required": True,
"type": "str"
},
"null_ssid_probe_resp": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"sensor_mode": {
"required": False,
"type": "str",
"choices": ["disable", "foreign", "both"]
},
"spoofed_deauth": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"weak_wep_iv": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"wireless_bridge": {
"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"]},
"vpn_ssl_web_user_bookmark": {
"required": False, "type": "dict", "default": None,
"options": {
"bookmarks": {"required": False, "type": "list",
"options": {
"additional_params": {"required": False, "type": "str"},
"apptype": {"required": False, "type": "str",
"choices": ["citrix", "ftp", "portforward",
"rdp", "smb", "ssh",
"telnet", "vnc", "web"]},
"description": {"required": False, "type": "str"},
"folder": {"required": False, "type": "str"},
"form_data": {"required": False, "type": "list",
"options": {
"name": {"required": True, "type": "str"},
"value": {"required": False, "type": "str"}
}},
"host": {"required": False, "type": "str"},
"listening_port": {"required": False, "type": "int"},
"load_balancing_info": {"required": False, "type": "str"},
"logon_password": {"required": False, "type": "str"},
"logon_user": {"required": False, "type": "str"},
"name": {"required": True, "type": "str"},
"port": {"required": False, "type": "int"},
"preconnection_blob": {"required": False, "type": "str"},
"preconnection_id": {"required": False, "type": "int"},
"remote_port": {"required": False, "type": "int"},
"security": {"required": False, "type": "str",
"choices": ["rdp", "nla", "tls",
"any"]},
"server_layout": {"required": False, "type": "str",
"choices": ["de-de-qwertz", "en-gb-qwerty", "en-us-qwerty",
"es-es-qwerty", "fr-fr-azerty", "fr-ch-qwertz",
"it-it-qwerty", "ja-jp-qwerty", "pt-br-qwerty",
"sv-se-qwerty", "tr-tr-qwerty", "failsafe"]},
"show_status_window": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"sso": {"required": False, "type": "str",
"choices": ["disable", "static", "auto"]},
"sso_credential": {"required": False, "type": "str",
"choices": ["sslvpn-login", "alternative"]},
"sso_credential_sent_once": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"sso_password": {"required": False, "type": "str"},
"sso_username": {"required": False, "type": "str"},
"url": {"required": False, "type": "str"}
}},
"custom_lang": {"required": False, "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_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
},
"wireless_controller_inter_controller": {
"required": False,
"type": "dict",
"default": None,
"options": {
"fast_failover_max": {
"required": False,
"type": "int"
},
"fast_failover_wait": {
"required": False,
"type": "int"
},
"inter_controller_key": {
"required": False,
"type": "str"
},
"inter_controller_mode": {
"required": False,
"type": "str",
"choices": ["disable", "l2-roaming", "1+1"]
},
"inter_controller_peer": {
"required": False,
"type": "list",
"options": {
"id": {
"required": True,
"type": "int"
},
"peer_ip": {
"required": False,
"type": "str"
},
"peer_port": {
"required": False,
"type": "int"
},
"peer_priority": {
"required": False,
"type": "str",
"choices": ["primary", "secondary"]
}
}
},
"inter_controller_pri": {
"required": False,
"type": "str",
"choices": ["primary", "secondary"]
}
}
}
}
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},
"wireless_controller_setting": {
"required": False, "type": "dict", "default": None,
"options": {
"account_id": {"required": False, "type": "str"},
"country": {"required": False, "type": "str",
"choices": ["NA", "AL", "DZ",
"AO", "AR", "AM",
"AU", "AT", "AZ",
"BH", "BD", "BB",
"BY", "BE", "BZ",
"BO", "BA", "BR",
"BN", "BG", "KH",
"CL", "CN", "CO",
"CR", "HR", "CY",
"CZ", "DK", "DO",
"EC", "EG", "SV",
"EE", "FI", "FR",
"GE", "DE", "GR",
"GL", "GD", "GU",
"GT", "HT", "HN",
"HK", "HU", "IS",
"IN", "ID", "IR",
"IE", "IL", "IT",
"JM", "JO", "KZ",
"KE", "KP", "KR",
"KW", "LV", "LB",
"LI", "LT", "LU",
"MO", "MK", "MY",
"MT", "MX", "MC",
"MA", "MZ", "MM",
"NP", "NL", "AN",
"AW", "NZ", "NO",
"OM", "PK", "PA",
"PG", "PY", "PE",
"PH", "PL", "PT",
"PR", "QA", "RO",
"RU", "RW", "SA",
"RS", "ME", "SG",
"SK", "SI", "ZA",
"ES", "LK", "SE",
"SD", "CH", "SY",
"TW", "TZ", "TH",
"TT", "TN", "TR",
"AE", "UA", "GB",
"US", "PS", "UY",
"UZ", "VE", "VN",
"YE", "ZB", "ZW",
"JP", "CA"]},
"duplicate_ssid": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"fapc_compatibility": {"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)
from mock import ANY
from ansible_collections.fortinet.fortios.plugins.module_utils.network.fortios.fortios import FortiOSHandler
try:
from ansible_collections.fortinet.fortios.plugins.modules import fortios_system_vdom_exception
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.fortinet.fortios.plugins.modules.fortios_system_vdom_exception.Connection')
return connection_class_mock
fos_instance = FortiOSHandler(connection_mock)
def test_system_vdom_exception_creation(mocker):
schema_method_mock = mocker.patch('ansible_collections.fortinet.fortios.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.fortinet.fortios.plugins.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result)
input_data = {
'username': '******',
'state': 'present',
'system_vdom_exception': {
'id': '3',
'object': 'log.fortianalyzer.setting',
'oid': '5',
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
},
"vpn_certificate_setting": {
"required": False,
"type": "dict",
"default": None,
"options": {
"certname_dsa1024": {
"required": False,
"type": "str"
},
"certname_dsa2048": {
"required": False,
"type": "str"
},
"certname_ecdsa256": {
"required": False,
"type": "str"
},
"certname_ecdsa384": {
"required": False,
"type": "str"
},
"certname_rsa1024": {
"required": False,
"type": "str"
},
"certname_rsa2048": {
"required": False,
"type": "str"
},
"check_ca_cert": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"check_ca_chain": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"cmp_save_extra_certs": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"cn_match": {
"required": False,
"type": "str",
"choices": ["substring", "value"]
},
"ocsp_default_server": {
"required": False,
"type": "str"
},
"ocsp_status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"ssl_min_proto_version": {
"required": False,
"type": "str",
"choices":
["default", "SSLv3", "TLSv1", "TLSv1-1", "TLSv1-2"]
},
"ssl_ocsp_option": {
"required": False,
"type": "str",
"choices": ["certificate", "server"]
},
"ssl_ocsp_status": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"strict_crl_check": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"strict_ocsp_check": {
"required": False,
"type": "str",
"choices": ["enable", "disable"]
},
"subject_match": {
"required": False,
"type": "str",
"choices": ["substring", "value"]
}
}
}
}
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_certificate(
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_certificate(
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)
