def get_device_instance(module, os_choices):
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) \
or provider.get('host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks,
# since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
optional_args = module.params['optional_args'] or {}
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as err:
module.fail_json(msg="cannot connect to device: {0}".format(str(err)))
return device
def get_device_instance(module):
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) \
or provider.get('host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
optional_args = module.params['optional_args'] or {}
try:
network_driver = get_network_driver(dev_os)
except ModuleImportError as e:
module.fail_json(msg="Failed to import napalm driver: " + str(e))
try:
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as err:
module.fail_json(msg="cannot connect to device: {0}".format(str(err)))
return device
def check_args(module, warnings):
provider = module.params['provider'] or {}
for key in eos_argument_spec:
if module._name == 'eos_user':
if (key not in [
'username', 'password', 'provider', 'transport',
'authorize'
] and module.params[key]):
warnings.append(
'argument %s has been deprecated and will be removed in a future version'
% key)
else:
if key not in ['provider', 'authorize'] and module.params[key]:
warnings.append(
'argument %s has been deprecated and will be removed in a future version'
% key)
# set argument's default value if not provided in input
# This is done to avoid unwanted argument deprecation warning
# in case argument is not given as input (outside provider).
for key in ARGS_DEFAULT_VALUE:
if not module.params.get(key, None):
module.params[key] = ARGS_DEFAULT_VALUE[key]
if provider:
for param in ('auth_pass', 'password'):
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
def main():
argument_spec = dict(
host=dict(required=True, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback, ["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback, ["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(default=True, type="bool"),
validate_certs=dict(default=False, type="bool"),
provider=dict(required=False, type="dict"),
partition=dict(required=False, type="str"),
)
module = AnsibleModule(argument_spec, supports_check_mode=False)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
use_ssl = module.params["use_ssl"]
username = module.params["username"]
validate_certs = module.params["validate_certs"]
kwargs = dict()
if port:
kwargs["port"] = port
session = Netscaler(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to login")
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
module.fail_json(msg=session_switch.content,
reason="Unable to Switch Partitions")
response = session.save_config()
if response.ok:
results = dict(changed=True, status_code=response.status_code)
else:
module.fail_json(msg=response.content)
return module.exit_json(**results)
def check_args(module, warnings):
provider = module.params['provider'] or {}
for key in sros_argument_spec:
if key != 'provider' and module.params[key]:
warnings.append('argument %s has been deprecated and will be removed in a future version' % key)
if provider:
for param in ('password',):
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
def update_module_provider_data(module):
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(param):
module.no_log_values.update(return_values(provider['optional_args'].get(param)))
if module.params.get('optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) \
or provider.get('host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
def check_args(module):
provider = module.params['provider'] or {}
for key in asa_argument_spec:
if key not in ['provider', 'authorize'] and module.params[key]:
module.warn('argument %s has been deprecated and will be removed in a future version' % key)
if provider:
for param in ('auth_pass', 'password'):
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
def check_args(module, warnings):
provider = module.params['provider'] or {}
for key in ios_argument_spec:
if module._name == 'ios_user':
if key not in ['password', 'provider', 'authorize'] and module.params[key]:
warnings.append('argument %s has been deprecated and will be in a future version' % key)
else:
if key not in ['provider', 'authorize'] and module.params[key]:
warnings.append('argument %s has been deprecated and will be removed in a future version' % key)
if provider:
for param in ('auth_pass', 'password'):
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
def main():
module = AnsibleModule(
argument_spec=dict(
platform=dict(
choices=[PLATFORM_NXAPI, PLATFORM_IOS, PLATFORM_EAPI, PLATFORM_F5, PLATFORM_ASA],
required=False,
),
host=dict(required=False),
username=dict(required=False, type="str"),
password=dict(required=False, type="str", no_log=True),
secret=dict(required=False, no_log=True),
transport=dict(required=False, choices=["http", "https"]),
port=dict(required=False, type="int"),
provider=dict(type="dict", required=False),
ntc_host=dict(required=False),
ntc_conf_file=dict(required=False),
system_image_file=dict(required=True),
kickstart_image_file=dict(required=False),
volume=dict(required=False, type="str"),
),
mutually_exclusive=[
["host", "ntc_host"],
["ntc_host", "secret"],
["ntc_host", "transport"],
["ntc_host", "port"],
["ntc_conf_file", "secret"],
["ntc_conf_file", "transport"],
["ntc_conf_file", "port"],
],
required_one_of=[["host", "ntc_host", "provider"]],
required_if=[["platform", PLATFORM_F5, ["volume"]]],
supports_check_mode=True,
)
if not HAS_PYNTC:
module.fail_json(msg="pyntc Python library not found.")
provider = module.params["provider"] or {}
no_log = ["password", "secret"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) != False:
module.params[param] = module.params.get(param) or pvalue
platform = module.params["platform"]
host = module.params["host"]
username = module.params["username"]
password = module.params["password"]
ntc_host = module.params["ntc_host"]
ntc_conf_file = module.params["ntc_conf_file"]
transport = module.params["transport"]
port = module.params["port"]
secret = module.params["secret"]
argument_check = {
"host": host,
"username": username,
"platform": platform,
"password": password,
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
if ntc_host is not None:
device = ntc_device_by_name(ntc_host, ntc_conf_file)
else:
kwargs = {}
if transport is not None:
kwargs["transport"] = transport
if port is not None:
kwargs["port"] = port
if secret is not None:
kwargs["secret"] = secret
device_type = platform
device = ntc_device(device_type, host, username, password, **kwargs)
system_image_file = module.params["system_image_file"]
kickstart_image_file = module.params["kickstart_image_file"]
volume = module.params["volume"]
if kickstart_image_file == "null":
kickstart_image_file = None
device.open()
pre_install_boot_options = device.get_boot_options()
changed = False
if not already_set(
boot_options=pre_install_boot_options,
system_image_file=system_image_file,
kickstart_image_file=kickstart_image_file,
volume=volume,
device=device,
):
changed = True
if not module.check_mode and changed == True:
if device.device_type == "nxos":
timeout = 600
device.set_timeout(timeout)
try:
start_time = time.time()
device.set_boot_options(system_image_file, kickstart=kickstart_image_file)
except:
pass
elapsed_time = time.time() - start_time
device.set_timeout(30)
try:
install_state = device.get_boot_options()
except:
install_state = {}
while elapsed_time < timeout and not install_state:
try:
install_state = device.get_boot_options()
except:
time.sleep(10)
elapsed_time += 10
else:
device.set_boot_options(
system_image_file, kickstart=kickstart_image_file, volume=volume
)
install_state = device.get_boot_options()
if not already_set(
boot_options=install_state,
system_image_file=system_image_file,
kickstart_image_file=kickstart_image_file,
volume=volume,
device=device,
):
module.fail_json(msg="Install not successful", install_state=install_state)
else:
install_state = pre_install_boot_options
device.close()
module.exit_json(changed=changed, install_state=install_state)
def main():
os_choices = [
'eos', 'junos', 'iosxr', 'fortios', 'ios', 'mock', 'nxos', 'nxos_ssh',
'panos', 'vyos', 'ros'
]
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
config_file=dict(type='str', required=False),
config=dict(type='str', required=False),
dev_os=dict(type='str', required=False, choices=os_choices),
commit_changes=dict(type='bool', required=True),
replace_config=dict(type='bool', required=False, default=False),
diff_file=dict(type='str', required=False, default=None),
get_diffs=dict(type='bool', required=False, default=True),
archive_file=dict(type='str', required=False, default=None)),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
config_file = module.params['config_file']
config = module.params['config']
commit_changes = module.params['commit_changes']
replace_config = module.params['replace_config']
diff_file = module.params['diff_file']
get_diffs = module.params['get_diffs']
archive_file = module.params['archive_file']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as e:
module.fail_json(msg="cannot connect to device: " + str(e))
try:
if archive_file is not None:
running_config = device.get_config(retrieve="running")["running"]
save_to_file(running_config, archive_file)
except Exception as e:
module.fail_json(msg="cannot retrieve running config:" + str(e))
try:
if replace_config and config_file:
device.load_replace_candidate(filename=config_file)
elif replace_config and config:
device.load_replace_candidate(config=config)
elif not replace_config and config_file:
device.load_merge_candidate(filename=config_file)
elif not replace_config and config:
device.load_merge_candidate(config=config)
else:
module.fail_json(
msg="You have to specify either config or config_file")
except Exception as e:
module.fail_json(msg="cannot load config: " + str(e))
try:
if get_diffs:
diff = device.compare_config().encode('utf-8')
changed = len(diff) > 0
else:
changed = True
diff = None
if diff_file is not None and get_diffs:
save_to_file(diff, diff_file)
except Exception as e:
module.fail_json(msg="cannot diff config: " + str(e))
try:
if module.check_mode or not commit_changes:
device.discard_config()
else:
if changed:
device.commit_config()
except Exception as e:
module.fail_json(msg="cannot install config: " + str(e))
try:
device.close()
except Exception as e:
module.fail_json(msg="cannot close device connection: " + str(e))
module.exit_json(changed=changed, msg=diff)
def main():
argument_spec = dict(host=dict(required=False, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback,
["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback,
["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(required=False, type="bool"),
validate_certs=dict(required=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"], type="str"),
partition=dict(required=False, type="str"),
vservername=dict(required=False, type="str"),
certkeyname=dict(required=False, type="str"),
ca_cert=dict(choices=["true", "false"],
required=False,
type="bool"),
crl_check=dict(choices=["Mandatory", "Optional"],
required=False,
type="str"),
ocsp_check=dict(choices=["Mandatory", "Optional"],
required=False,
type="str"),
skip_ca_name=dict(choices=["true", "false"],
required=False,
type="str"),
sni_cert=dict(choices=["true", "false"],
required=False,
type="str"))
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
# module specific args that can be represented as both str or int are normalized to Netscaler's representation for diff comparison in case provider is used
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
if not state:
state = "present"
use_ssl = module.params["use_ssl"]
if use_ssl is None:
use_ssl = True
username = module.params["username"]
validate_certs = module.params["validate_certs"]
if validate_certs is None:
validate_certs = False
certkeyname = module.params["certkeyname"]
if certkeyname:
certkeyname = certkeyname.upper()
args = dict(vservername=module.params["vservername"],
certkeyname=module.params["certkeyname"],
ca=module.params["ca_cert"],
crlcheck=module.params["crl_check"],
ocspcheck=module.params["ocsp_check"],
skipcaname=module.params["skip_ca_name"],
snicert=module.params["sni_cert"])
# check for required values, this allows all values to be passed in provider
#argument_check = dict(host=host, vservername=args["vservername"])
#for key, val in argument_check.items():
# if not val:
# module.fail_json(msg="The {} parameter is required".format(key))
#proposed = dict(
# vservername=module.params["vservername"],
# certkeyname=module.params["certkeyname"]
#)
#kwargs = dict()
#if port:
# kwargs["port"] = port
# check for required values, this allows all values to be passed in provider
argument_check = dict(host=host,
certkeyname=args["certkeyname"],
vserver_name=args["vservername"])
for key, val in argument_check.items():
if not val:
module.fail_json(msg="The {} parameter is required".format(key))
proposed = dict(
(k, v) for k, v in args.items() if isinstance(v, bool) or v)
kwargs = dict()
if port:
kwargs["port"] = port
session = SSLVServer(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to Login",
netscaler_response=session_login.json())
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
session_logout = session.logout()
module.fail_json(msg="Unable to Switch Partitions",
netscaler_response=session_switch.json(),
logout=session_logout.ok)
#existing_attrs = args.keys()
#existing = session.get_existing_attrs(proposed["vservername"], existing_attrs)
#all_existing = session.get_sslvserver_sslcertkey_binding(proposed["vservername"])
all_existing = session.get_sslvserver_sslcertkey_binding(proposed)
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = delete_sslvserver_sslcertkey_binding(session, module,
proposed, all_existing)
session_logout = session.logout()
results["logout"] = session_logout.ok
return module.exit_json(**results)
def main():
argument_spec = dict(
host=dict(required=True, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback, ["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback, ["ANSIBLE_NET_PASSWORD"]), no_log=True),
use_ssl=dict(default=True, type="bool"),
validate_certs=dict(default=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"], default="present", type="str"),
partition=dict(required=False, type="str"),
server_name=dict(required=True, type="str"),
server_port=dict(required=True, type="str"),
servicegroup_name=dict(required=True, type="str")
)
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
use_ssl = module.params["use_ssl"]
username = module.params["username"]
validate_certs = module.params["validate_certs"]
service_port = module.params["server_port"]
if service_port == "*":
service_port = 65535
else:
try:
service_port = int(service_port)
except ValueError:
module.fail_json(msg="'server_port' Must be a Number from 0 to 65535, or '*'")
proposed = dict(
port=service_port,
servername=module.params["server_name"],
servicegroupname=module.params["servicegroup_name"]
)
kwargs = dict()
if port:
kwargs["port"] = port
session = ServiceGroup(host, username, password, use_ssl, validate_certs, **kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to login")
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
module.fail_json(msg=session_switch.content, reason="Unable to Switch Partitions")
all_existing = session.get_server_bindings(proposed["servicegroupname"])
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = delete_server_binding(session, module, proposed, all_existing)
return module.exit_json(**results)
def main():
argument_spec = dict(host=dict(required=True, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback,
["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback,
["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(default=True, type="bool"),
validate_certs=dict(default=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"],
default="present",
type="str"),
partition=dict(required=False, type="str"),
comment=dict(required=False, type="str"),
ip_address=dict(required=False, type="str"),
server_name=dict(required=True, type="str"),
server_state=dict(choices=["disabled", "enabled"],
default="enabled",
type="str"),
traffic_domain=dict(required=False,
type="str",
default="0"))
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
use_ssl = module.params["use_ssl"]
username = module.params["username"]
validate_certs = module.params["validate_certs"]
args = dict(comment=module.params["comment"],
ipaddress=module.params["ip_address"],
name=module.params["server_name"],
state=module.params["server_state"].upper(),
td=module.params["traffic_domain"])
# "if isinstance(v, bool) or v" should be used if a bool variable is added to args
proposed = dict((k, v) for k, v in args.items() if v)
kwargs = dict()
if port:
kwargs["port"] = port
if "ipaddress" in proposed:
check_ip = Server.validate_ip(proposed["ipaddress"])
if not check_ip:
module.fail_json(
msg="{} is an invalid IP".format(proposed["ipaddress"]))
session = Server(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to login")
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
module.fail_json(msg=session_switch.content,
reason="Unable to Switch Partitions")
existing_attrs = args.keys()
existing = session.get_existing_attrs(proposed["name"], existing_attrs)
if state == "present":
results = change_config(session, module, proposed, existing)
else:
results = delete_server(session, module, proposed["name"], existing)
module.exit_json(**results)
def main():
module = AnsibleModule(
argument_spec=dict(
platform=dict(
choices=[PLATFORM_NXAPI, PLATFORM_IOS, PLATFORM_EAPI, PLATFORM_F5, PLATFORM_ASA],
required=False,
),
host=dict(required=False),
username=dict(required=False, type="str"),
password=dict(required=False, type="str", no_log=True),
secret=dict(required=False, no_log=True),
transport=dict(required=False, choices=["http", "https"]),
port=dict(required=False, type="int"),
provider=dict(type="dict", required=False),
ntc_host=dict(required=False),
ntc_conf_file=dict(required=False),
system_image_file=dict(required=True),
kickstart_image_file=dict(required=False),
volume=dict(required=False, type="str"),
reboot=dict(required=False, type="bool", default=False),
),
mutually_exclusive=[
["host", "ntc_host"],
["ntc_host", "secret"],
["ntc_host", "transport"],
["ntc_host", "port"],
["ntc_conf_file", "secret"],
["ntc_conf_file", "transport"],
["ntc_conf_file", "port"],
],
required_one_of=[["host", "ntc_host", "provider"]],
required_if=[["platform", PLATFORM_F5, ["volume"]]],
supports_check_mode=True,
)
if not HAS_PYNTC:
module.fail_json(msg="pyntc Python library not found.")
# TODO: Change to fail_json when deprecating older pyntc
if not HAS_PYNTC_VERSION:
module.warn("Support for pyntc version < 0.0.9 is being deprecated; please upgrade pyntc")
# TODO: Remove warning when deprecating reboot option on non-F5 devices
module.warn("Support for installing the OS without rebooting may be deprecated in the future")
provider = module.params["provider"] or {}
no_log = ["password", "secret"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
# TODO: Figure out exactly the purpose of this and correct truthiness or noneness
if module.params.get(param) != False:
module.params[param] = module.params.get(param) or pvalue
platform = module.params["platform"]
host = module.params["host"]
username = module.params["username"]
password = module.params["password"]
ntc_host = module.params["ntc_host"]
ntc_conf_file = module.params["ntc_conf_file"]
transport = module.params["transport"]
port = module.params["port"]
secret = module.params["secret"]
reboot = module.params["reboot"]
# TODO: Remove checks if we require reboot for non-F5 devices
if platform == "cisco_nxos_nxapi" and not reboot:
module.fail_json(msg='NXOS requires setting the "reboot" parameter to True')
if platform != "cisco_nxos_nxapi" and reboot and not HAS_PYNTC_VERSION:
module.fail_json(
msg='Using the "reboot" parameter for non-NXOS devices' "requires pyntc version > 0.0.8"
)
argument_check = {
"host": host,
"username": username,
"platform": platform,
"password": password,
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
if ntc_host is not None:
device = ntc_device_by_name(ntc_host, ntc_conf_file)
else:
kwargs = {}
if transport is not None:
kwargs["transport"] = transport
if port is not None:
kwargs["port"] = port
if secret is not None:
kwargs["secret"] = secret
device_type = platform
device = ntc_device(device_type, host, username, password, **kwargs)
system_image_file = module.params["system_image_file"]
kickstart_image_file = module.params["kickstart_image_file"]
volume = module.params["volume"]
if kickstart_image_file == "null":
kickstart_image_file = None
device.open()
pre_install_boot_options = device.get_boot_options()
if not module.check_mode:
# TODO: Remove conditional when deprecating older pyntc
if HAS_PYNTC_VERSION:
try:
# TODO: Remove conditional if we require reboot for non-F5 devices
if reboot or device.device_type == "f5_tmos_icontrol":
changed = device.install_os(
image_name=system_image_file, kickstart=kickstart_image_file, volume=volume
)
else:
# TODO: Remove support if we require reboot for non-F5 devices
changed = device.set_boot_options(system_image_file)
except (
CommandError,
CommandListError,
FileSystemNotFoundError,
NotEnoughFreeSpaceError,
NTCFileNotFoundError,
OSInstallError,
RebootTimeoutError,
) as e:
module.fail_json(msg=e.message)
except Exception as e:
module.fail_json(msg=str(e))
if (
reboot
and device.device_type == "f5_tmos_icontrol"
and pre_install_boot_options["active_volume"] != volume
):
try:
changed = True
device.reboot(confirm=True, volume=volume)
except RuntimeError:
module.fail_json(
msg="Attempted reboot but did not boot to desired volume",
original_volume=pre_install_boot_options["active_volume"],
expected_volume=volume,
)
install_state = device.get_boot_options()
# TODO: Remove contents of else when deprecating older pyntc
else:
changed = False
install_state = pre_install_boot_options
if not already_set(
boot_options=pre_install_boot_options,
system_image_file=system_image_file,
kickstart_image_file=kickstart_image_file,
volume=volume,
device=device,
):
changed = True
if device.device_type == "nxos":
timeout = 600
device.set_timeout(timeout)
try:
start_time = time.time()
device.set_boot_options(system_image_file, kickstart=kickstart_image_file)
except:
pass
elapsed_time = time.time() - start_time
device.set_timeout(30)
try:
install_state = device.get_boot_options()
except:
install_state = {}
while elapsed_time < timeout and not install_state:
try:
install_state = device.get_boot_options()
except:
time.sleep(10)
elapsed_time += 10
else:
device.set_boot_options(
system_image_file, kickstart=kickstart_image_file, volume=volume
)
install_state = device.get_boot_options()
if not already_set(
boot_options=pre_install_boot_options,
system_image_file=system_image_file,
kickstart_image_file=kickstart_image_file,
volume=volume,
device=device,
):
module.fail_json(msg="Install not successful", install_state=install_state)
else:
if HAS_PYNTC_VERSION:
changed = device._image_booted(
image_name=system_image_file, kickstart=kickstart_image_file, volume=volume
)
# TODO: Remove contents of else when deprecating older pyntc
else:
changed = already_set(
boot_options=pre_install_boot_options,
system_image_file=system_image_file,
kickstart_image_file=kickstart_image_file,
volume=volume,
device=device,
)
install_state = pre_install_boot_options
device.close()
module.exit_json(changed=changed, install_state=install_state)
def main():
argument_spec = dict(host=dict(required=False, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback,
["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback,
["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(required=False, type="bool"),
validate_certs=dict(required=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"], type="str"),
partition=dict(required=False, type="str"),
csvserver_name=dict(required=True, type="str"),
rp_name=dict(required=True, type="str"),
rp_priority=dict(required=False, type="int"),
rp_gotopriorityexpression=dict(required=False,
type="str"),
rp_bindpoint=dict(choices=['REQUEST', 'RESPONSE'],
required=False,
type="str"),
rp_targetlbvserver=dict(required=False, type="str"))
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
# module specific args that can be represented as both str or int are normalized to Netscaler's representation for diff comparison in case provider is used
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
if not state:
state = "present"
use_ssl = module.params["use_ssl"]
if use_ssl is None:
use_ssl = True
username = module.params["username"]
validate_certs = module.params["validate_certs"]
if validate_certs is None:
validate_certs = False
rp_name = module.params["rp_name"]
if rp_name:
rp_name = rp_name.upper()
rp_bindpoint = module.params["rp_bindpoint"]
rp_gotopriorityexpression = module.params["rp_gotopriorityexpression"]
if rp_gotopriorityexpression:
rp_gotopriorityexpression = rp_gotopriorityexpression.upper()
rp_targetlbvserver = module.params["rp_targetlbvserver"]
if rp_targetlbvserver:
rp_targetlbvserver = rp_targetlbvserver.upper()
args = dict(
name=module.params["csvserver_name"],
priority=module.params["rp_priority"],
policyname=module.params["rp_name"],
gotopriorityexpression=module.params["rp_gotopriorityexpression"],
bindpoint=module.params["rp_bindpoint"],
targetlbvserver=module.params["rp_targetlbvserver"])
# check for required values, this allows all values to be passed in provider
argument_check = dict(host=host, csvserver_name=args["name"])
for key, val in argument_check.items():
if not val:
module.fail_json(msg="The {} parameter is required".format(key))
#proposed = dict(
# name=module.params["csvserver_name"],
# priority=module.params["rp_priority"],
# policyname=module.params["rp_name"],
# gotopriorityexpression=module.params["rp_gotopriorityexpression"]
#)
proposed = dict(
(k, v) for k, v in args.items() if isinstance(v, bool) or v)
kwargs = dict()
if port:
kwargs["port"] = port
session = CSVServer(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to Login",
netscaler_response=session_login.json())
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
session_logout = session.logout()
module.fail_json(msg="Unable to Switch Partitions",
netscaler_response=session_switch.json(),
logout=session_logout.ok)
#existing_attrs = args.keys()
#existing = session.get_existing_attrs(proposed["name"], existing_attrs)
all_existing = session.get_csvserver_responderpolicy_binding(proposed)
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = delete_csvserver_responderpolicy_binding(
session, module, proposed, all_existing)
session_logout = session.logout()
results["logout"] = session_logout.ok
return module.exit_json(**results)
def test_unknown_type(self):
self.assertRaises(TypeError, frozenset, return_values(object()))
def main():
argument_spec = dict(host=dict(required=True, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback,
["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback,
["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(default=True, type="bool"),
validate_certs=dict(default=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"],
default="present",
type="str"),
partition=dict(required=False, type="str"),
ca_cert=dict(choices=["true", "false"],
required=False,
type="bool"),
cert_key_name=dict(required=True, type="str"),
crl_check=dict(choices=["Mandatory", "Optional"],
required=False,
type="str"),
ocsp_check=dict(choices=["Mandatory", "Optional"],
required=False,
type="str"),
skip_ca_name=dict(choices=["true", "false"],
required=False,
type="bool"),
sni_cert=dict(choices=["true", "false"],
required=False,
type="bool"),
vserver_name=dict(required=True, type="str"))
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
use_ssl = module.params["use_ssl"]
username = module.params["username"]
validate_certs = module.params["validate_certs"]
args = dict(ca=module.params["ca_cert"],
crlcheck=module.params["crl_check"],
certkeyname=module.params["cert_key_name"],
ocspcheck=module.params["ocsp_check"],
skipcaname=module.params["skip_ca_name"],
snicert=module.params["sni_cert"],
vservername=module.params["vserver_name"])
proposed = dict(
(k, v) for k, v in args.items() if isinstance(v, bool) or v)
kwargs = dict()
if port:
kwargs["port"] = port
session = LBVServer(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to login")
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
module.fail_json(msg=session_switch.content,
reason="Unable to Switch Partitions")
all_existing = session.get_certkey_bindings(proposed)
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = delete_certkey_binding(session, module, proposed,
all_existing)
return module.exit_json(**results)
def test_unknown_type(self):
self.assertRaises(TypeError, frozenset, return_values(object()))
def main():
module = AnsibleModule(
argument_spec=dict(
provider=dict(type='dict', required=True),
state=dict(type='str', required=True),
network_view=dict(type='str', required=True),
network=dict(type='str', required=False),
extattrs=dict(type='dict', required=False),
comment=dict(type='str', required=False),
filters=dict(type='str', required=False),
dhcp_options=dict(type='list', required=False),
members=dict(type='list', required=False),
),
required_one_of=(
['network', 'filters'],
),
supports_check_mode=False
)
if not HAS_INFOBLOX_CLIENT:
raise Exception('infoblox-client is not installed. Please see details here: https://github.com/infobloxopen/infoblox-client')
provider = module.params['provider'] or {}
no_log = ['password']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
else:
module.fail_json(msg="Invalid item found in provider.")
valid_provider = ['host', 'username', 'password', 'validate_certs', 'wapi_version']
for param, pvalue in provider.items():
if param in valid_provider:
module.params[param] = module.params.get(param) or pvalue
required_params = ['host', 'username', 'password']
for param in required_params:
if not module.params.get(param):
module.fail_json(msg="Provider option {} is required.".format(provider))
host = module.params['host']
username = module.params['username']
password = module.params['password']
validate_certs = module.params.get('validate_certs', False)
wapi_version = module.params.get('wapi_version', BASE_WAPI)
state = module.params['state']
network_view = module.params.get('network_view', 'default')
network = module.params['network']
extattrs = module.params['extattrs']
comment = module.params['comment']
filters = module.params['filters']
dhcp_options = module.params.get('dhcp_options', None)
members = module.params['members']
if members is not None:
module.fail_json(msg="Members has not yet been implemented.")
opts = {'host': host, 'username': username, 'password': password, 'ssl_verify': validate_certs,
'silent_ssl_warnings': validate_certs is False, wapi_version: wapi_version}
conn = connector.Connector(opts)
extattrs = build_extattrs(module, conn, extattrs)
if state == 'get':
if network:
obj = get_network(module, conn, network_view, network=network)
if isinstance(obj, list):
module.exit_json(changed=False, results=obj)
else:
module.fail_json(msg="Network {} was not found".format(network))
elif filters:
# TODO
pass
get_network(module, conn, network_view, filters=filters)
elif state == 'present':
return_fields = objects.Network._return_fields
obj = get_network(module, conn, network_view, network=network)
if isinstance(obj, list):
if compare_fields(module, conn, module.params, obj[0]) is False:
results = objects.Network.create(conn, update_if_exists=True,
network_view=network_view, cidr=network,
comment=comment, options=dhcp_options, extattrs=extattrs)
obj = get_network(module, conn, network_view, network=network)
module.exit_json(changed=True, results=str(obj))
else:
module.exit_json(changed=False, results=obj)
else:
results = objects.Network.create(conn,
network_view=network_view, cidr=network,
comment=comment, options=dhcp_options, extattrs=extattrs)
obj = get_network(module, conn, network_view, network=network)
module.exit_json(changed=True, results=str(obj))
elif state == 'absent':
find_network = objects.Network.search(conn, network_view=network_view, cidr=network)
if find_network is None:
module.exit_json(changed=False, results="Network {} did not exit".format(network))
find_network.delete()
module.exit_json(changed=True, results="Network {} has been deleted".format(network))
def main():
argument_spec = dict(
host=dict(required=False, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback, ["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback, ["ANSIBLE_NET_PASSWORD"]), no_log=True),
use_ssl=dict(required=False, type="bool"),
validate_certs=dict(required=False, type="bool"),
provider=dict(required=False, type="dict"),
partition=dict(required=False, type="str"),
)
module = AnsibleModule(argument_spec, supports_check_mode=False)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
use_ssl = module.params["use_ssl"]
if use_ssl is None:
use_ssl = True
username = module.params["username"]
validate_certs = module.params["validate_certs"]
if validate_certs is None:
validate_certs = False
# check for required values, this allows all values to be passed in provider
argument_check = dict(host=host)
for key, val in argument_check.items():
if not val:
module.fail_json(msg="The {} parameter is required".format(key))
kwargs = dict()
if port:
kwargs["port"] = port
session = Netscaler(host, username, password, use_ssl, validate_certs, **kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to Login", netscaler_response=session_login.json())
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
session_logout = session.logout()
module.fail_json(msg="Unable to Switch Partitions", netscaler_response=session_switch.json(), logout=session_logout.ok)
response = session.save_config()
if response.ok:
results = dict(changed=True, status_code=response.status_code)
else:
session_logout = session.logout()
module.fail_json(msg="Unable to Save the Configuration", netscaler_response=response.json(), logout=session_logout.ok)
session_logout = session.logout()
results["logout"] = session_logout.ok
return module.exit_json(**results)
def main():
argument_spec = dict(
host=dict(required=False, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback, ["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback, ["ANSIBLE_NET_PASSWORD"]), no_log=True),
use_ssl=dict(required=False, type="bool"),
validate_certs=dict(required=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(required=False, choices=["absent", "present"], type="str"),
partition=dict(required=False, type="str"),
comment=dict(required=False, type="str"),
config_override = dict(choices=[True, False], type="bool"),
ip_address=dict(required=False, type="str"),
server_name=dict(required=False, type="str"),
server_state=dict(choices=["disabled", "enabled"], type="str"),
traffic_domain=dict(required=False, type="str")
)
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
# module specific args that can be represented as both str or int are normalized to Netscaler's representation for diff comparison in case provider is used
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
if not state:
state = "present"
use_ssl = module.params["use_ssl"]
if use_ssl is None:
use_ssl = True
username = module.params["username"]
validate_certs = module.params["validate_certs"]
if validate_certs is None:
validate_certs = False
server_state=module.params["server_state"]
if server_state:
server_state = server_state.upper()
traffic_domain = module.params["traffic_domain"]
if traffic_domain:
traffic_domain = str(traffic_domain)
else:
traffic_domain = "0"
args = dict(
comment=module.params["comment"],
ipaddress=module.params["ip_address"],
name=module.params["server_name"],
state=server_state,
td=traffic_domain
)
# check for required values, this allows all values to be passed in provider
argument_check = dict(host=host, server_name=args["name"])
for key, val in argument_check.items():
if not val:
module.fail_json(msg="The {} parameter is required".format(key))
# "if isinstance(v, bool) or v" should be used if a bool variable is added to args
proposed = dict((k, v) for k, v in args.items() if v)
kwargs = dict()
if port:
kwargs["port"] = port
if "ipaddress" in proposed:
check_ip = Server.validate_ip(proposed["ipaddress"])
if not check_ip:
module.fail_json(msg="{} is an invalid IP".format(proposed["ipaddress"]))
session = Server(host, username, password, use_ssl, validate_certs, **kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to Login", netscaler_response=session_login.json())
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
session_logout = session.logout()
module.fail_json(msg="Unable to Switch Partitions", netscaler_response=session_switch.json(), logout=session_logout.ok)
existing_attrs = args.keys()
existing = session.get_existing_attrs(proposed["name"], existing_attrs)
if state == "present":
results = change_config(session, module, proposed, existing)
else:
results = delete_server(session, module, proposed["name"], existing)
session_logout = session.logout()
results["logout"] = session_logout.ok
module.exit_json(**results)
def main():
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
dev_os=dict(type='str', required=False),
destination=dict(type='str', required=True),
source=dict(type='str', required=False),
ttl=dict(type='str', required=False),
ping_timeout=dict(type='str', required=False),
size=dict(type='str', required=False),
count=dict(type='str', required=False),
vrf=dict(type='str', required=False),
),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
destination = module.params['destination']
ping_optional_args = {}
ping_args = ['source', 'ttl', 'ping_timeout', 'size', 'count', 'vrf']
for param, pvalue in module.params.items():
if param in ping_args and pvalue is not None:
ping_optional_args[param] = pvalue
if 'ping_timeout' in ping_optional_args:
ping_optional_args['timeout'] = ping_optional_args['ping_timeout']
ping_optional_args.pop('ping_timeout')
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
except ModuleImportError as e:
module.fail_json(msg="Failed to import napalm driver: " + str(e))
try:
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as e:
module.fail_json(msg="cannot connect to device: " + str(e))
ping_response = device.ping(destination, **ping_optional_args)
try:
device.close()
except Exception as e:
module.fail_json(msg="cannot close device connection: " + str(e))
module.exit_json(changed=False, results=ping_response)
def main():
argument_spec = dict(
host=dict(required=True, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback, ["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback, ["ANSIBLE_NET_PASSWORD"]), no_log=True),
use_ssl=dict(default=True, type="bool"),
validate_certs=dict(default=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"], default="present", type="str"),
partition=dict(required=False, type="str"),
monitor_name=dict(required=True, type="str"),
servicegroup_name=dict(required=True, type="str"),
weight=dict(required=False, type="str")
)
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
use_ssl = module.params["use_ssl"]
username = module.params["username"]
validate_certs = module.params["validate_certs"]
args = dict(
monitor_name=module.params["monitor_name"],
servicegroupname=module.params["servicegroup_name"],
weight=module.params["weight"]
)
# "if isinstance(v, bool) or v" should be used if a bool variable is added to args
proposed = dict((k, v) for k, v in args.items() if v)
kwargs = dict()
if port:
kwargs["port"] = port
session = ServiceGroup(host, username, password, use_ssl, validate_certs, **kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to login")
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
module.fail_json(msg=session_switch.content, reason="Unable to Switch Partitions")
all_existing = session.get_monitor_bindings(proposed["servicegroupname"])
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = delete_monitor_binding(session, module, proposed, all_existing)
return module.exit_json(**results)
def main():
argument_spec = dict(host=dict(required=False, type="str"),
port=dict(required=False, type="int"),
username=dict(fallback=(env_fallback,
["ANSIBLE_NET_USERNAME"])),
password=dict(fallback=(env_fallback,
["ANSIBLE_NET_PASSWORD"]),
no_log=True),
use_ssl=dict(required=False, type="bool"),
validate_certs=dict(required=False, type="bool"),
provider=dict(required=False, type="dict"),
state=dict(choices=["absent", "present"], type="str"),
partition=dict(required=False, type="str"),
app_flow_log=dict(choices=VALID_APP_FLOW,
required=False,
type="str"),
comment=dict(required=False, type="str"),
ip_address=dict(required=False, type="str"),
vservername=dict(required=False, type="str"),
clientauth=dict(required=False, type="str"),
clientcert=dict(required=False, type="str"),
ssl2=dict(required=False, type="str"),
ssl3=dict(required=False, type="str"),
tls1=dict(required=False, type="str"),
tls11=dict(required=False, type="str"),
tls12=dict(required=False, type="str"),
ocspstapling=dict(required=False, type="str"))
module = AnsibleModule(argument_spec, supports_check_mode=True)
provider = module.params["provider"] or {}
no_log = ["password"]
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is None:
module.params[param] = pvalue
# module specific args that can be represented as both str or int are normalized to Netscaler's representation for diff comparison in case provider is used
host = module.params["host"]
partition = module.params["partition"]
password = module.params["password"]
port = module.params["port"]
state = module.params["state"]
if not state:
state = "present"
use_ssl = module.params["use_ssl"]
if use_ssl is None:
use_ssl = True
username = module.params["username"]
validate_certs = module.params["validate_certs"]
if validate_certs is None:
validate_certs = False
app_flow_log = module.params["app_flow_log"]
if app_flow_log:
app_flow_log = app_flow_log.upper()
args = dict(appflowlog=app_flow_log,
vservername=module.params["vservername"],
clientauth=module.params["clientauth"],
clientcert=module.params["clientcert"],
ssl2=module.params["ssl2"],
ssl3=module.params["ssl3"],
tls1=module.params["tls1"],
tls11=module.params["tls11"],
tls12=module.params["tls12"],
ocspstapling=module.params["ocspstapling"])
# check for required values, this allows all values to be passed in provider
argument_check = dict(host=host, vservername=args["vservername"])
for key, val in argument_check.items():
if not val:
module.fail_json(msg="The {} parameter is required".format(key))
# "if isinstance(v, bool) or v" should be used if a bool variable is added to args
proposed = dict((k, v) for k, v in args.items() if v)
kwargs = dict()
if port:
kwargs["port"] = port
session = SSLVServer(host, username, password, use_ssl, validate_certs,
**kwargs)
session_login = session.login()
if not session_login.ok:
module.fail_json(msg="Unable to Login",
netscaler_response=session_login.json())
if partition:
session_switch = session.switch_partition(partition)
if not session_switch.ok:
session_logout = session.logout()
module.fail_json(msg="Unable to Switch Partitions",
netscaler_response=session_switch.json(),
logout=session_logout.ok)
#existing_attrs = args.keys()
#all_existing = session.get_existing_attrs(proposed, existing_attrs)
all_existing = session.get_sslvserver_vservername(proposed)
if state == "present":
results = change_config(session, module, proposed, all_existing)
else:
results = unset_sslvserver(session, module, proposed, all_existing)
session_logout = session.logout()
results["logout"] = session_logout.ok
return module.exit_json(**results)
def main():
os_choices = [
'eos', 'junos', 'iosxr', 'fortios', 'ios', 'mock', 'nxos', 'nxos_ssh',
'panos', 'vyos', 'ros'
]
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False),
timeout=dict(type='int', required=False, default=60),
dev_os=dict(type='str', required=False, choices=os_choices),
optional_args=dict(required=False, type='dict', default=None),
args=dict(required=True, type='dict', default=None),
),
supports_check_mode=False)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
args = module.params['args']
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as e:
module.fail_json(msg="cannot connect to device: " + str(e))
try:
cli_response = device.cli(**args)
except Exception as e:
module.fail_json(msg="{}".format(e))
try:
device.close()
except Exception as e:
module.fail_json(msg="cannot close device connection: " + str(e))
module.exit_json(changed=False, results=cli_response)
def test_return_values(self):
for data, expected in self.dataset:
self.assertEquals(frozenset(return_values(data)), expected)
def main():
os_choices = [
'eos', 'junos', 'iosxr', 'fortios', 'ios', 'mock', 'nxos', 'nxos_ssh',
'panos', 'vyos', 'ros'
]
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False),
dev_os=dict(type='str', required=False, choices=os_choices),
timeout=dict(type='int', required=False, default=60),
ignore_notimplemented=dict(type='bool', required=False, default=False),
args=dict(type='dict', required=False, default=None),
optional_args=dict(type='dict', required=False, default=None),
filter=dict(type='list', required=False, default=['facts']),
),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
filter_list = module.params['filter']
args = module.params['args'] or {}
ignore_notimplemented = module.params['ignore_notimplemented']
implementation_errors = []
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
# open device connection
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception as e:
module.fail_json(msg="cannot connect to device: " + str(e))
# retreive data from device
facts = {}
NAPALM_GETTERS = [
getter for getter in dir(network_driver) if getter.startswith("get_")
]
for getter in filter_list:
getter_function = "get_{}".format(getter)
if getter_function not in NAPALM_GETTERS:
module.fail_json(msg="filter not recognized: " + getter)
try:
get_func = getattr(device, getter_function)
result = get_func(**args.get(getter, {}))
facts[getter] = result
except NotImplementedError:
if ignore_notimplemented:
implementation_errors.append(getter)
else:
module.fail_json(
msg="The filter {} is not supported in napalm-{} [get_{}()]"
.format(getter, dev_os, getter))
except Exception as e:
module.fail_json(
msg="[{}] cannot retrieve device data: ".format(getter) +
str(e))
# close device connection
try:
device.close()
except Exception as e:
module.fail_json(msg="cannot close device connection: " + str(e))
new_facts = {}
# Prepend all facts with napalm_ for unique namespace
for filter_name, filter_value in facts.items():
# Make napalm get_facts to be directly accessible as variables
if filter_name == "facts":
for fact_name, fact_value in filter_value.items():
napalm_fact_name = "napalm_" + fact_name
new_facts[napalm_fact_name] = fact_value
new_filter_name = "napalm_" + filter_name
new_facts[new_filter_name] = filter_value
results = {'ansible_facts': new_facts}
if ignore_notimplemented:
results['not_implemented'] = sorted(implementation_errors)
module.exit_json(**results)
def test_return_values(self):
for data, expected in self.dataset:
self.assertEquals(frozenset(return_values(data)), expected)
def main():
os_choices = ['eos', 'junos', 'ios', 'vyos', 'ros']
module = AnsibleModule(argument_spec=dict(
hostname=dict(type='str', required=False, aliases=['host']),
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
provider=dict(type='dict', required=False),
timeout=dict(type='int', required=False, default=60),
optional_args=dict(required=False, type='dict', default=None),
dev_os=dict(type='str', required=False, choices=os_choices),
destination=dict(type='str', required=True),
source=dict(type='str', required=False),
ttl=dict(type='str', required=False),
ping_timeout=dict(type='str', required=False),
size=dict(type='str', required=False),
count=dict(type='str', required=False),
vrf=dict(type='str', required=False),
),
supports_check_mode=True)
if not napalm_found:
module.fail_json(msg="the python module napalm is required")
provider = module.params['provider'] or {}
no_log = ['password', 'secret']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
if provider.get('optional_args') and provider['optional_args'].get(
param):
module.no_log_values.update(
return_values(provider['optional_args'].get(param)))
if module.params.get(
'optional_args') and module.params['optional_args'].get(param):
module.no_log_values.update(
return_values(module.params['optional_args'].get(param)))
# allow host or hostname
provider['hostname'] = provider.get('hostname', None) or provider.get(
'host', None)
# allow local params to override provider
for param, pvalue in provider.items():
if module.params.get(param) is not False:
module.params[param] = module.params.get(param) or pvalue
hostname = module.params['hostname']
username = module.params['username']
dev_os = module.params['dev_os']
password = module.params['password']
timeout = module.params['timeout']
destination = module.params['destination']
ping_optional_args = {}
ping_args = ['source', 'ttl', 'ping_timeout', 'size', 'count', 'vrf']
for param, pvalue in module.params.items():
if param in ping_args and pvalue is not None:
ping_optional_args[param] = pvalue
if 'ping_timeout' in ping_optional_args:
ping_optional_args['timeout'] = ping_optional_args['ping_timeout']
ping_optional_args.pop('ping_timeout')
argument_check = {
'hostname': hostname,
'username': username,
'dev_os': dev_os,
'password': password
}
for key, val in argument_check.items():
if val is None:
module.fail_json(msg=str(key) + " is required")
# use checks outside of ansible defined checks, since params come can come from provider
if dev_os not in os_choices:
module.fail_json(msg="dev_os is not set to " + str(os_choices))
if module.params['optional_args'] is None:
optional_args = {}
else:
optional_args = module.params['optional_args']
try:
network_driver = get_network_driver(dev_os)
device = network_driver(hostname=hostname,
username=username,
password=password,
timeout=timeout,
optional_args=optional_args)
device.open()
except Exception, e:
module.fail_json(msg="cannot connect to device: " + str(e))
