def main(): """ Main function """ argument_spec = dict( credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), chassis=dict(required=True, type='dict')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True ) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] chassis = input_params['chassis'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = chassis_get(fos_user_name, fos_password, fos_ip_addr, fos_version, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_chassis = response["Response"]["chassis"] to_human_chassis(resp_chassis) diff_attributes = generate_diff(result, resp_chassis, chassis) result["diff_attributes"] = diff_attributes result["resp_chassis"] = resp_chassis result["chassis"] = chassis if len(diff_attributes) > 0: ret_code = to_fos_chassis(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) if not module.check_mode: ret_code = chassis_patch(fos_user_name, fos_password, fos_ip_addr, fos_version, https, auth, vfid, result, diff_attributes) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True else: logout(fos_ip_addr, https, auth, result) module.exit_json(**result) logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), syslog_servers=dict(required=True, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] syslog_servers = input_params['syslog_servers'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = syslog_server_get(fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_ss = response["Response"]["syslog-server"] if isinstance(resp_ss, list): current_servers = resp_ss else: current_servers = [resp_ss] diff_servers = [] for new_server in syslog_servers: for current_server in current_servers: if new_server["server"] == current_server["server"]: to_human_syslog_server(current_server) diff_attributes = generate_diff(result, current_server, new_server) if len(diff_attributes) > 0: result["current_server"] = current_server diff_attributes["server"] = new_server["server"] ret_code = to_fos_syslog_server(diff_attributes, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) diff_servers.append(diff_attributes) add_servers = [] for new_server in syslog_servers: found = False for current_server in current_servers: if new_server["server"] == current_server["server"]: found = True if not found: new_yang_server = {} secured = ("secured_mode" in new_server and new_serer["secured_mode"] == True) if secured: for k, v in new_server.items(): new_yang_server[k] = v else: for k, v in new_server.items(): if k == "server": new_yang_server[k] = v ret_code = to_fos_syslog_server(new_yang_server, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) add_servers.append(new_yang_server) delete_servers = [] for current_server in current_servers: found = False for new_server in syslog_servers: if new_server["server"] == current_server["server"]: found = True if not found: delete_server = {} delete_server["server"] = current_server["server"] delete_servers.append(delete_server) result["resp_ss"] = resp_ss result["syslog_servers"] = syslog_servers result["diff_servers"] = diff_servers result["add_servers"] = add_servers result["delete_servers"] = delete_servers if len(diff_servers) > 0: if not module.check_mode: ret_code = syslog_server_patch(fos_ip_addr, https, auth, vfid, result, diff_servers) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(add_servers) > 0: if not module.check_mode: ret_code = syslog_server_post(fos_ip_addr, https, auth, vfid, result, add_servers) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(delete_servers) > 0: if not module.check_mode: ret_code = syslog_server_delete(fos_ip_addr, https, auth, vfid, result, delete_servers) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), ports=dict(required=True, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] ports = input_params['ports'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = fc_port_get(fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_ports = response["Response"]["fibrechannel"] if isinstance(resp_ports, list): current_ports = resp_ports else: current_ports = [resp_ports] diff_ports = [] for port in ports: for current_port in current_ports: if port["name"] == current_port["name"]: to_human_fc(current_port) diff_attributes = generate_diff(result, current_port, port) if len(diff_attributes) > 0: result["current_port"] = current_port diff_attributes["name"] = port["name"] ret_code = to_fos_fc(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) diff_ports.append(diff_attributes) result["diff_ports"] = diff_ports if len(diff_ports) > 0: if not module.check_mode: ret_code = fc_port_patch(fos_ip_addr, https, auth, vfid, result, diff_ports) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True else: logout(fos_ip_addr, https, auth, result) module.exit_json(**result) logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def singleton_helper(module, fos_ip_addr, fos_user_name, fos_password, https, ssh_hostkeymust, throttle, vfid, module_name, obj_name, attributes, result, timeout): if not is_full_human(attributes, result): module.exit_json(**result) if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result, timeout) if ret_code != 0: module.exit_json(**result) result['ssh_hostkeymust'] = ssh_hostkeymust ret_code, response = singleton_get(fos_user_name, fos_password, fos_ip_addr, module_name, obj_name, fos_version, https, auth, vfid, result, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) resp_attributes = response["Response"][str_to_yang(obj_name)] to_human_singleton(module_name, obj_name, resp_attributes) diff_attributes = generate_diff(result, resp_attributes, attributes) # any object specific special processing if module_name == "brocade_maps" and obj_name == "maps_config": # relay_ip_address and domain_name needs to be specifid # at the same time based on FOS REST requirements if "relay_ip_address" in diff_attributes and "domain_name" not in diff_attributes: diff_attributes["domain_name"] = resp_attributes["domain_name"] result["kept the same"] = "domain_name" elif "relay_ip_address" not in diff_attributes and "domain_name" in diff_attributes: diff_attributes["relay_ip_address"] = resp_attributes[ "relay_ip_address"] result["kept the same"] = "relay_ip_address" if "relay_ip_address" in diff_attributes and diff_attributes[ "relay_ip_address"] == None: result["failed"] = True result['msg'] = "must specify relay_ip_address if configured empty" exit_after_login(fos_ip_addr, https, auth, result, module, timeout) elif "domain_name" in diff_attributes and diff_attributes[ "domain_name"] == None: result["failed"] = True result['msg'] = "must specify domain_name if configured empty" exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["diff_attributes"] = diff_attributes result["current_attributes"] = resp_attributes result["new_attributes"] = attributes if len(diff_attributes) > 0: ret_code = to_fos_singleton(module_name, obj_name, diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) if not module.check_mode: ret_code = 0 ret_code = singleton_patch(fos_user_name, fos_password, fos_ip_addr, module_name, obj_name, fos_version, https, auth, vfid, result, diff_attributes, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["changed"] = True else: logout(fos_ip_addr, https, auth, result, timeout) module.exit_json(**result) logout(fos_ip_addr, https, auth, result, timeout) module.exit_json(**result)
def list_helper(module, fos_ip_addr, fos_user_name, fos_password, https, ssh_hostkeymust, throttle, vfid, module_name, list_name, entries, all_entries, result, timeout): if not is_full_human(entries, result): module.exit_json(**result) if all_entries == None: result["all_entries_default"] = all_entries all_entries = True if vfid is None: vfid = 128 if entries == None: entries = [] ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result, timeout) if ret_code != 0: module.exit_json(**result) ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) current_entries = response["Response"][str_to_yang(list_name)] if not isinstance(current_entries, list): if current_entries is None: current_entries = [] else: current_entries = [current_entries] to_human_list(module_name, list_name, current_entries, result) # for switch list object only, we only support one for now # and allow users to not specifcy the WWN of the switch # thus missing key of the entry. We'll get it from the switch if module_name == "brocade_fibrechannel_switch" and list_name == "fibrechannel_switch": if len(entries) != 1: result["failed"] = True result["msg"] = "Only one entry in an array is supported" exit_after_login(fos_ip_addr, https, auth, result, module, timeout) entries[0]["name"] = current_entries[0]["name"] if module_name == "brocade_access_gateway" and list_name == "port_group": for port_group in current_entries: if "port_group_n_ports" in port_group and port_group[ "port_group_n_ports"] == None: port_group["port_group_n_ports"] = {"n_port": None} if "port_group_f_ports" in port_group and port_group[ "port_group_f_ports"] == None: port_group["port_group_f_ports"] = {"f_port": None} diff_entries = [] for entry in entries: for current_entry in current_entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): diff_attributes = generate_diff(result, current_entry, entry) if len(diff_attributes) > 0: for key in list_entry_keys(module_name, list_name): diff_attributes[key] = entry[key] diff_entries.append(diff_attributes) if module_name == "brocade_security" and list_name == "user_config": new_diff_entries = [] for diff_entry in diff_entries: # password canot change using patch update # any entries with password are popp'ed off. if not "password" in diff_entry: new_diff_entries.append(diff_entry) diff_entries = new_diff_entries ret_code = to_fos_list(module_name, list_name, diff_entries, result) result["diff_retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) add_entries = [] for entry in entries: # check to see if the new entry matches any of the old ones found = False for current_entry in current_entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): found = True break if not found: new_entry = {} for k, v in entry.items(): new_entry[k] = v add_entries.append(new_entry) if module_name == "brocade_logging" and list_name == "syslog_server": new_add_entries = [] for add_entry in add_entries: secured = ("secured_mode" in add_entry and add_entry["secured_mode"] == True) if not secured: new_add_entry = {} new_add_entry["server"] = add_entry["server"] new_add_entries.append(new_add_entry) else: new_add_entries.append(add_entry) add_entries = new_add_entries ret_code = to_fos_list(module_name, list_name, add_entries, result) result["add_retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) delete_entries = [] for current_entry in current_entries: found = False for entry in entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): found = True break if not found: delete_entry = {} for key in list_entry_keys(module_name, list_name): delete_entry[key] = current_entry[key] delete_entries.append(delete_entry) ret_code = to_fos_list(module_name, list_name, delete_entries, result) result["delete_retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["response"] = response result["current_entries"] = current_entries result["diff_entries"] = diff_entries result["add_entries"] = add_entries result["delete_entries"] = delete_entries if len(diff_entries) > 0: if not module.check_mode: ret_code = 0 ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, diff_entries, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["changed"] = True if len(add_entries) > 0: if not module.check_mode: ret_code = list_post(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, add_entries, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["changed"] = True if len(delete_entries) > 0 and all_entries: if not module.check_mode: ret_code = list_delete(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, delete_entries, ssh_hostkeymust, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) result["changed"] = True logout(fos_ip_addr, https, auth, result, timeout) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), ipfilter_policies=dict(required=False, type='list'), active_policy=dict(required=False, type='str'), delete_policies=dict(required=False, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] ipfilter_policies = input_params['ipfilter_policies'] active_policy = input_params['active_policy'] delete_policies = input_params['delete_policies'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = ipfilter_policy_get(fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_ir = response["Response"]["ipfilter-policy"] if isinstance(resp_ir, list): c_policies = resp_ir else: c_policies = [resp_ir] # convert REST to human readable format first for c_policy in c_policies: to_human_ipfilter_policy(c_policy) # if active policy is not None, then we make sure # the policy is active or activate. and return # policy creation or update does not happen at the same # time if active_policy != None: found_disabled_policy = False found_active_policy = False activate_list = [] for c_policy in c_policies: if c_policy["name"] == active_policy: if c_policy["is_policy_active"] == False: found_disabled_policy = True activate_dict = { "name": c_policy["name"], "action": "activate" } activate_list.append(activate_dict) else: found_active_policy = True activate_dict = { "name": c_policy["name"], } activate_list.append(activate_dict) if found_disabled_policy: if not module.check_mode: ret_code = ipfilter_policy_patch(fos_ip_addr, https, auth, vfid, result, activate_list) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True elif found_active_policy: result["same active policy"] = activate_list else: result["failed"] = True result["msg"] = "could not find matching policy" logout(fos_ip_addr, https, auth, result) module.exit_json(**result) # if delete policy is not None, then we make sure # the policy is not present. # policy creation or update does not happen at the same # time if delete_policies != None: to_delete = [] for delete_policy in delete_policies: found = False for c_policy in c_policies: if c_policy["name"] == delete_policy["name"]: found = True break if found: to_delete.append(delete_policy) if len(to_delete) > 0: if not module.check_mode: ret_code = ipfilter_policy_delete(fos_ip_addr, https, auth, vfid, result, to_delete) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result) diff_policies = [] for new_ip in ipfilter_policies: for c_policy in c_policies: if new_ip["name"] == c_policy["name"]: diff_attributes = generate_diff(result, c_policy, new_ip) if len(diff_attributes) > 0: result["c_policy"] = c_policy diff_attributes["name"] = new_ip["name"] ret_code = to_fos_ipfilter_policy(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) diff_policies.append(diff_attributes) add_policies = [] for new_ip in ipfilter_policies: found = False for c_policy in c_policies: if new_ip["name"] == c_policy["name"]: found = True if not found: new_policy = {} for k, v in new_ip.items(): new_policy[k] = v ret_code = to_fos_ipfilter_policy(new_policy, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) add_policies.append(new_policy) result["resp_ir"] = resp_ir result["ipfilter_policies"] = ipfilter_policies result["diff_policies"] = diff_policies result["add_policies"] = add_policies result["delete_policies"] = delete_policies if len(diff_policies) > 0: if not module.check_mode: ret_code = ipfilter_policy_patch(fos_ip_addr, https, auth, vfid, result, diff_policies) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(add_policies) > 0: if not module.check_mode: ret_code = ipfilter_policy_post(fos_ip_addr, https, auth, vfid, result, add_policies) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict( credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), ipfilter_rules=dict(required=True, type='list')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True ) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] ipfilter_rules = input_params['ipfilter_rules'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = ipfilter_rule_get( fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_ir = response["Response"]["ipfilter-rule"] if isinstance(resp_ir, list): c_rules = resp_ir else: c_rules = [resp_ir] # convert everything to human readable from REST for c_rule in c_rules: to_human_ipfilter_rule(c_rule) diff_rules = [] for new_ir in ipfilter_rules: for c_rule in c_rules: if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]: diff_attributes = generate_diff(result, c_rule, new_ir) if len(diff_attributes) > 0: result["c_rule"] = c_rule diff_attributes["policy_name"] = new_ir["policy_name"] diff_attributes["index"] = new_ir["index"] ret_code = to_fos_ipfilter_rule(diff_attributes, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) diff_rules.append(diff_attributes) add_rules = [] for new_ir in ipfilter_rules: found = False for c_rule in c_rules: if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]: found = True if not found: new_yang_rule = {} for k, v in new_ir.items(): new_yang_rule[k] = v ret_code = to_fos_ipfilter_rule(new_yang_rule, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) add_rules.append(new_yang_rule) delete_rules = [] for c_rule in c_rules: found = False for new_ir in ipfilter_rules: if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]: found = True if not found: delete_rule = {} delete_rule["policy-name"] = c_rule["policy_name"] delete_rule["index"] = c_rule["index"] delete_rules.append(delete_rule) result["resp_ir"] = resp_ir result["ipfilter_rules"] = ipfilter_rules result["diff_rules"] = diff_rules result["add_rules"] = add_rules result["delete_rules"] = delete_rules if len(diff_rules) > 0: if not module.check_mode: ret_code = ipfilter_rule_patch( fos_ip_addr, https, auth, vfid, result, diff_rules) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(add_rules) > 0: if not module.check_mode: ret_code = ipfilter_rule_post( fos_ip_addr, https, auth, vfid, result, add_rules) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True # if len(delete_rules) > 0: # if not module.check_mode: # ret_code = ipfilter_rule_delete( # fos_ip_addr, https, # auth, vfid, result, delete_rules) # if ret_code != 0: # exit_after_login(fos_ip_addr, https, auth, result, module) # # result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict( credential=dict(required=True, type='dict', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), clock_server=dict(required=False, type='dict')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True ) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] clock_server = input_params['clock_server'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = clock_server_get( fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_clock = response["Response"]["clock-server"] to_human_clock_server(resp_clock) if "ntp_server_address" in resp_clock and "server_address" in resp_clock["ntp_server_address"]: if not isinstance(resp_clock["ntp_server_address"]["server_address"], list): new_list = [] new_list.append(resp_clock["ntp_server_address"]["server_address"]) resp_clock["ntp_server_address"]["server_address"] = new_list diff_attributes = generate_diff(result, resp_clock, clock_server) result["diff_attributes"] = diff_attributes result["clock_server"] = clock_server result["resp_clock"] = resp_clock if len(diff_attributes) > 0: ret_code = to_fos_clock_server(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) if not module.check_mode: ret_code = clock_server_patch( fos_ip_addr, https, auth, vfid, result, diff_attributes) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True else: logout(fos_ip_addr, https, auth, result) module.exit_json(**result) logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), switch=dict(required=True, type='dict')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] throttle = input_params['throttle'] vfid = input_params['vfid'] switch = input_params['switch'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = fc_switch_get(fos_user_name, fos_password, fos_ip_addr, fos_version, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_switch = response["Response"]["fibrechannel-switch"] to_human_switch(resp_switch) if "dns_servers" in resp_switch: if resp_switch[ "dns_servers"] is not None and "dns_server" in resp_switch[ "dns_servers"]: if not isinstance(resp_switch["dns_servers"]["dns_server"], list): new_list = [] new_list.append(resp_switch["dns_servers"]["dns_server"]) resp_switch["dns_servers"]["dns_server"] = new_list if "ip_address" in resp_switch: if resp_switch[ "ip_address"] is not None and "ip_address" in resp_switch[ "ip_address"]: if not isinstance(resp_switch["ip_address"]["ip_address"], list): new_list = [] new_list.append(resp_switch["ip_address"]["ip_address"]) resp_switch["ip_address"]["ip_address"] = new_list if "ip_static_gateway_list" in resp_switch: if resp_switch[ "ip_static_gateway_list"] is not None and "ip_static_gateway" in resp_switch[ "ip_static_gateway_list"]: if not isinstance( resp_switch["ip_static_gateway_list"]["ip_static_gateway"], list): new_list = [] new_list.append( resp_switch["ip_static_gateway_list"]["ip_static_gateway"]) resp_switch["ip_static_gateway_list"][ "ip_static_gateway"] = new_list diff_attributes = generate_diff(result, resp_switch, switch) result["diff_attributes"] = diff_attributes result["resp_switch"] = resp_switch result["switch"] = switch if len(diff_attributes) > 0: # let's add name key to it diff_attributes["name"] = resp_switch["name"] ret_code = to_fos_switch(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) if not module.check_mode: ret_code = fc_switch_patch(fos_user_name, fos_password, fos_ip_addr, fos_version, https, auth, vfid, result, diff_attributes) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True else: logout(fos_ip_addr, https, auth, result) module.exit_json(**result) logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), module_name=dict(required=True, type='str'), list_name=dict(required=True, type='str'), all_entries=dict(required=False, type='bool'), longer_timeout=dict(required=False, type='int'), entries=dict(required=True, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] ssh_hostkeymust = True if 'ssh_hostkeymust' in input_params['credential']: ssh_hostkeymust = input_params['credential']['ssh_hostkeymust'] throttle = input_params['throttle'] vfid = input_params['vfid'] module_name = input_params['module_name'] list_name = input_params['list_name'] entries = input_params['entries'] all_entries = input_params['all_entries'] longer_timeout = input_params['longer_timeout'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) current_entries = response["Response"][list_name] if not isinstance(current_entries, list): current_entries = [current_entries] to_human_list(module_name, list_name, current_entries, result) result["current_entries"] = current_entries diff_entries = [] for entry in entries: for current_entry in current_entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): diff_attributes = generate_diff(result, current_entry, entry) if len(diff_attributes) > 0: for key in list_entry_keys(module_name, list_name): diff_attributes[key] = entry[key] diff_entries.append(diff_attributes) ret_code = to_fos_list(module_name, list_name, diff_entries, result) result["diff_retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) add_entries = [] for entry in entries: # check to see if the new entry matches any of the old ones found = False for current_entry in current_entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): found = True break if not found: new_entry = {} for k, v in entry.items(): new_entry[k] = v add_entries.append(new_entry) ret_code = to_fos_list(module_name, list_name, add_entries, result) result["add_retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) delete_entries = [] for current_entry in current_entries: found = False for entry in entries: if list_entry_keys_matched(entry, current_entry, module_name, list_name): found = True break if not found: delete_entry = {} for key in list_entry_keys(module_name, list_name): delete_entry[key] = current_entry[key] delete_entries.append(delete_entry) result["response"] = response result["current_entries"] = current_entries result["diff_entries"] = diff_entries result["add_entries"] = add_entries result["delete_entries"] = delete_entries if len(diff_entries) > 0: if not module.check_mode: ret_code = 0 if longer_timeout != None: ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, diff_entries, ssh_hostkeymust, longer_timeout) else: ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, diff_entries, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(add_entries) > 0 and all_entries: if not module.check_mode: ret_code = list_post(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, add_entries, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(delete_entries) > 0 and all_entries: if not module.check_mode: ret_code = list_delete(fos_user_name, fos_password, fos_ip_addr, module_name, list_name, fos_version, https, auth, vfid, result, delete_entries, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict(credential=dict(required=True, type='dict'), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), user_configs=dict(required=False, type='list'), delete_user_configs=dict(required=False, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] ssh_hostkeymust = True if 'ssh_hostkeymust' in input_params['credential']: ssh_hostkeymust = input_params['credential']['ssh_hostkeymust'] throttle = input_params['throttle'] vfid = input_params['vfid'] user_configs = input_params['user_configs'] delete_user_configs = input_params['delete_user_configs'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) ret_code, response = user_config_get(fos_ip_addr, https, auth, vfid, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_uc = response["Response"]["user-config"] if isinstance(resp_uc, list): c_user_configs = resp_uc else: c_user_configs = [resp_uc] for c_user_config in c_user_configs: if "virtual-fabric-role-id-list" in c_user_config and not isinstance( c_user_config["virtual-fabric-role-id-list"], list): c_user_config["virtual-fabric-role-id-list"] = [ c_user_config["virtual-fabric-role-id-list"] ] # convert REST to human readable format first for c_user_config in c_user_configs: to_human_user_config(c_user_config) # if delete user config is not None, then we make sure # the user config is not present. # user config creation or update does not happen at the same # time if delete_user_configs != None: to_delete = [] for delete_user_config in delete_user_configs: found = False for c_user_config in c_user_configs: if c_user_config["name"] == delete_user_config["name"]: found = True break if found: to_delete.append(delete_user_config) if len(to_delete) > 0: if not module.check_mode: ret_code = user_config_delete(fos_ip_addr, https, auth, vfid, result, to_delete) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result) diff_user_configs = [] for new_uc in user_configs: for c_user_config in c_user_configs: if new_uc["name"] == c_user_config["name"]: diff_attributes = generate_diff(result, c_user_config, new_uc) # cannot change password using patch # so skip for diff identification if "password" in diff_attributes: diff_attributes.pop("password") if len(diff_attributes) > 0: result["c_user_config"] = c_user_config diff_attributes["name"] = new_uc["name"] ret_code = to_fos_user_config(diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) diff_user_configs.append(diff_attributes) add_user_configs = [] for new_uc in user_configs: found = False for c_user_config in c_user_configs: if new_uc["name"] == c_user_config["name"]: found = True if not found: new_user_config = {} for k, v in new_uc.items(): new_user_config[k] = v ret_code = to_fos_user_config(new_user_config, result) result["retcode"] = ret_code if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) add_user_configs.append(new_user_config) result["resp_uc"] = resp_uc result["user_configs"] = user_configs result["diff_user_configs"] = diff_user_configs result["add_user_configs"] = add_user_configs if len(diff_user_configs) > 0: if not module.check_mode: ret_code = user_config_patch(fos_user_name, fos_password, fos_ip_addr, fos_version, https, auth, vfid, result, diff_user_configs, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True if len(add_user_configs) > 0: if not module.check_mode: ret_code = user_config_post(fos_ip_addr, https, auth, vfid, result, add_user_configs) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True logout(fos_ip_addr, https, auth, result) module.exit_json(**result)
def main(): """ Main function """ argument_spec = dict( credential=dict(required=True, type='dict', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), module_name=dict(required=True, type='str'), obj_name=dict(required=True, type='str'), attributes=dict(required=True, type='dict')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True ) input_params = module.params # Set up state variables fos_ip_addr = input_params['credential']['fos_ip_addr'] fos_user_name = input_params['credential']['fos_user_name'] fos_password = input_params['credential']['fos_password'] https = input_params['credential']['https'] ssh_hostkeymust = True if 'ssh_hostkeymust' in input_params['credential']: ssh_hostkeymust = input_params['credential']['ssh_hostkeymust'] throttle = input_params['throttle'] vfid = input_params['vfid'] module_name = input_params['module_name'] obj_name = input_params['obj_name'] attributes = input_params['attributes'] result = {"changed": False} if vfid is None: vfid = 128 ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name, fos_password, https, throttle, result) if ret_code != 0: module.exit_json(**result) result['ssh_hostkeymust'] = ssh_hostkeymust ret_code, response = singleton_get(fos_user_name, fos_password, fos_ip_addr, module_name, obj_name, fos_version, https, auth, vfid, result, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) resp_attributes = response["Response"][obj_name] to_human_singleton(module_name, obj_name, resp_attributes) diff_attributes = generate_diff(result, resp_attributes, attributes) # any object specific special processing if module_name == "brocade-maps" and obj_name == "maps-config": # relay_ip_address and domain_name needs to be specifid # at the same time based on FOS REST requirements if "relay_ip_address" in diff_attributes and "domain_name" not in diff_attributes: diff_attributes["domain_name"] = resp_attributes["domain_name"] result["kept the same"] = "domain_name" elif "relay_ip_address" not in diff_attributes and "domain_name" in diff_attributes: diff_attributes["relay_ip_address"] = resp_attributes["relay_ip_address"] result["kept the same"] = "relay_ip_address" if "relay_ip_address" in diff_attributes and diff_attributes["relay_ip_address"] == None: result["failed"] = True result['msg'] = "must specify relay_ip_address if configured empty" exit_after_login(fos_ip_addr, https, auth, result, module) elif "domain_name" in diff_attributes and diff_attributes["domain_name"] == None: result["failed"] = True result['msg'] = "must specify domain_name if configured empty" exit_after_login(fos_ip_addr, https, auth, result, module) result["diff_attributes"] = diff_attributes result["resp_attributes"] = resp_attributes result["attributes"] = attributes if len(diff_attributes) > 0: ret_code = to_fos_singleton(module_name, obj_name, diff_attributes, result) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) if not module.check_mode: ret_code = singleton_patch(fos_user_name, fos_password, fos_ip_addr, module_name, obj_name, fos_version, https, auth, vfid, result, diff_attributes, ssh_hostkeymust) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module) result["changed"] = True else: logout(fos_ip_addr, https, auth, result) module.exit_json(**result) logout(fos_ip_addr, https, auth, result) module.exit_json(**result)