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 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 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))