def full_url_get(is_https, fos_ip_addr, path): if isinstance(is_https, bool): if is_https: return HTTPS + fos_ip_addr + str_to_yang(path), True else: return HTTP + fos_ip_addr + str_to_yang(path), False elif is_https.lower() == SELF_SIGNED: return HTTPS + fos_ip_addr + str_to_yang(path), False else: # by default, return HTTP return HTTP + fos_ip_addr + str_to_yang(path), False
def singleton_get(login, password, fos_ip_addr, module_name, obj_name, fos_version, is_https, auth, vfid, result, ssh_hostkeymust, timeout): """ retrieve existing user config configuration :param fos_ip_addr: ip address of FOS switch :type fos_ip_addr: str :param is_https: indicate to use HTTP or HTTPS :type is_https: bool :param auth: authorization struct from login :type struct: dict :param result: dict to keep track of execution msgs :type result: dict :return: code to indicate failure or success :rtype: int :return: dict of ipfilter policy configurations :rtype: dict """ if module_name == "brocade_chassis" and obj_name == "chassis": return chassis_get(login, password, fos_ip_addr, fos_version, is_https, auth, vfid, result, ssh_hostkeymust, timeout) if module_name == "brocade_fibrechannel_configuration" and obj_name == "fabric": return fabric_get(login, password, fos_ip_addr, fos_version, is_https, auth, vfid, result, ssh_hostkeymust, timeout) if module_name == "brocade_fibrechannel_configuration" and obj_name == "port_configuration": return port_configuration_get(login, password, fos_ip_addr, fos_version, is_https, auth, vfid, result, ssh_hostkeymust, timeout) # get is not support for these modules. Just return empty if module_name == "brocade_security" and obj_name == "security_certificate_action": return 0, ({"Response": {str_to_yang(obj_name): {}}}) if module_name == "brocade_security" and obj_name == "security_certificate_generate": return 0, ({"Response": {str_to_yang(obj_name): {}}}) if module_name == "brocade_security" and obj_name == "sshutil_public_key_action": return 0, ({"Response": {str_to_yang(obj_name): {}}}) full_url, validate_certs = full_url_get( is_https, fos_ip_addr, REST_PREFIX + module_name + "/" + obj_name) ret, resp = url_get_to_dict(fos_ip_addr, is_https, auth, vfid, result, full_url, timeout) if ret == ERROR_LIST_EMPTY: # return empty dict. GET isn't supported return 0, ({"Response": {str_to_yang(obj_name): {}}}) return ret, resp
def singleton_xml_str(result, obj_name, attributes): obj_name_yang = str_to_yang(obj_name) xml_str = "" xml_str = xml_str + "<" + obj_name_yang + ">" for k, v in attributes.items(): xml_str = xml_str + "<" + k + ">" if isinstance(v, dict): for k1, v1 in v.items(): if isinstance(v1, list): for entry in v1: xml_str = xml_str + "<" + k1 + ">" + str( entry) + "</" + k1 + ">" else: xml_str = xml_str + "<" + k1 + ">" + str( v1) + "</" + k1 + ">" else: xml_str = xml_str + str(v) xml_str = xml_str + "</" + k + ">" xml_str = xml_str + "</" + obj_name_yang + ">" return xml_str
def list_xml_str(result, module_name, list_name, entries): list_name_yang = str_to_yang(list_name) xml_str = "" for entry in entries: xml_str = xml_str + "<" + list_name_yang + ">" # add the key entries first for k, v in entry.items(): if str_to_human(k) in list_entry_keys(module_name, list_name): result[k] = "key identified" xml_str = xml_str + "<" + k + ">" + str(v) + "</" + k + ">" # add non key entries next for k, v in entry.items(): if str_to_human(k) not in list_entry_keys(module_name, list_name): xml_str = xml_str + "<" + k + ">" if isinstance(v, dict): for k1, v1 in v.items(): if isinstance(v1, list): for entry in v1: xml_str = xml_str + "<" + k1 + ">" + str( entry) + "</" + k1 + ">" else: if v1 == None: xml_str = xml_str + "<" + k1 + "></" + k1 + ">" else: xml_str = xml_str + "<" + k1 + ">" + str( v1) + "</" + k1 + ">" else: if v == None: xml_str = xml_str else: xml_str = xml_str + str(v) xml_str = xml_str + "</" + k + ">" xml_str = xml_str + "</" + list_name_yang + ">" return xml_str
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'), timeout=dict(required=False, type='float'), gather_subset=dict(required=True, type='list')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) 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'] timeout = input_params['timeout'] vfid = input_params['vfid'] gather_subset = input_params['gather_subset'] 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, timeout) if ret_code != 0: module.exit_json(**result) facts = {} facts['ssh_hostkeymust'] = ssh_hostkeymust if gather_subset is not None: for subset in gather_subset: if subset != "all" and subset not in valid_areas: result["failed"] = True result[ "msg"] = "Request for unknown module and object " + subset logout(fos_ip_addr, https, auth, result, timeout) module.exit_json(**result) for area in valid_areas: if (gather_subset is None or area in gather_subset or "all" in gather_subset): get_list = False get_singleton = False if area == "brocade_access_gateway_port_group": module_name = "brocade_access_gateway" list_name = "port_group" get_list = True elif area == "brocade_access_gateway_n_port_map": module_name = "brocade_access_gateway" list_name = "n_port_map" get_list = True elif area == "brocade_access_gateway_f_port_list": module_name = "brocade_access_gateway" list_name = "f_port_list" get_list = True elif area == "brocade_access_gateway_device_list": module_name = "brocade_access_gateway" list_name = "device_list" get_list = True elif area == "brocade_access_gateway_policy": module_name = "brocade_access_gateway" obj_name = "policy" get_singleton = True elif area == "brocade_access_gateway_n_port_settings": module_name = "brocade_access_gateway" obj_name = "n_port_settings" get_singleton = True elif area == "brocade_interface_fibrechannel": module_name = "brocade_interface" list_name = "fibrechannel" get_list = True elif area == "brocade_fibrechannel_switch": module_name = "brocade_fibrechannel_switch" list_name = "fibrechannel_switch" get_list = True elif area == "brocade_logging_syslog_server": module_name = "brocade_logging" list_name = "syslog_server" get_list = True elif area == "brocade_security_ipfilter_rule": module_name = "brocade_security" list_name = "ipfilter_rule" get_list = True elif area == "brocade_security_ipfilter_policy": module_name = "brocade_security" list_name = "ipfilter_policy" get_list = True elif area == "brocade_security_user_config": module_name = "brocade_security" list_name = "user_config" get_list = True elif area == "brocade_security_security_certificate": module_name = "brocade_security" list_name = "security_certificate" get_list = True elif area == "brocade_security_sshutil_public_key": module_name = "brocade_security" list_name = "sshutil_public_key" get_list = True elif area == "brocade_media_media_rdp": module_name = "brocade_media" list_name = "media_rdp" get_list = True elif area == "brocade_fibrechannel_trunk_trunk": module_name = "brocade_fibrechannel_trunk" list_name = "trunk" get_list = True elif area == "brocade_fibrechannel_trunk_performance": module_name = "brocade_fibrechannel_trunk" list_name = "performance" get_list = True elif area == "brocade_fibrechannel_trunk_trunk_area": module_name = "brocade_fibrechannel_trunk" list_name = "trunk_area" get_list = True elif area == "brocade_fabric_fabric_switch": module_name = "brocade_fabric" list_name = "fabric_switch" get_list = True elif area == "brocade_security_password_cfg": module_name = "brocade_security" obj_name = "password_cfg" get_singleton = True elif area == "brocade_chassis_chassis": module_name = "brocade_chassis" obj_name = "chassis" get_singleton = True elif area == "brocade_fibrechannel_configuration_fabric": module_name = "brocade_fibrechannel_configuration" obj_name = "fabric" get_singleton = True elif area == "brocade_fibrechannel_configuration_port_configuration": module_name = "brocade_fibrechannel_configuration" obj_name = "port_configuration" get_singleton = True elif area == "brocade_time_clock_server": module_name = "brocade_time" obj_name = "clock_server" get_singleton = True elif area == "brocade_time_time_zone": module_name = "brocade_time" obj_name = "time_zone" get_singleton = True elif area == "brocade_logging_audit": module_name = "brocade_logging" obj_name = "audit" get_singleton = True elif area == "brocade_snmp_system": module_name = "brocade_snmp" obj_name = "system" get_singleton = True if get_singleton: 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: result[module_name + "_" + obj_name + "_get"] = ret_code exit_after_login(fos_ip_addr, https, auth, result, module, timeout) obj = response["Response"][str_to_yang(obj_name)] to_human_singleton(module_name, obj_name, obj) facts[area] = obj elif get_list: 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: result[module_name + "_" + list_name + "_get"] = ret_code exit_after_login(fos_ip_addr, https, auth, result, module, timeout) obj_list = response["Response"][str_to_yang(list_name)] if not isinstance(obj_list, list): if obj_list is None: obj_list = [] else: obj_list = [obj_list] to_human_list(module_name, list_name, obj_list, result) facts[area] = obj_list elif area == "brocade_zoning": ret_code, response = defined_get(fos_ip_addr, https, auth, vfid, result, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) zoning = {} zoning["defined-configuration"] = ( response["Response"]["defined-configuration"]) ret_code, response = effective_get(fos_ip_addr, https, auth, vfid, result, timeout) if ret_code != 0: exit_after_login(fos_ip_addr, https, auth, result, module, timeout) zoning["effective-configuration"] = ( response["Response"]["effective-configuration"]) to_human_zoning(zoning["effective-configuration"]) facts[area] = zoning result["ansible_facts"] = facts 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 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_delete_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 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) delete_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 found: new_entry = {} for k, v in entry.items(): new_entry[k] = v delete_entries.append(new_entry) ret_code = to_fos_list(module_name, list_name, delete_entries, result) result["add_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["delete_entries"] = delete_entries if len(delete_entries) > 0: 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', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), timeout=dict(required=False, type='float'), pid=dict(required=True, type='str')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) 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'] timeout = input_params['timeout'] vfid = input_params['vfid'] pid = input_params['pid'] 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, timeout) if ret_code != 0: module.exit_json(**result) facts = {} facts['ssh_hostkeymust'] = ssh_hostkeymust module_name = "brocade_fabric" list_name = "fabric_switch" 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: result["list_get"] = ret_code exit_after_login(fos_ip_addr, https, auth, result, module, timeout) obj_list = response["Response"][str_to_yang(list_name)] if not isinstance(obj_list, list): if obj_list is None: obj_list = [] else: obj_list = [obj_list] to_human_list(module_name, list_name, obj_list, result) result["obj_list"] = obj_list did = int(pid, 16) >> 16 result["did"] = did ret_dict = {} for obj in obj_list: if obj["domain_id"] == str(did): ret_dict[list_name] = obj result["ansible_facts"] = ret_dict 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', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), timeout=dict(required=False, type='float'), module_name=dict(required=True, type='str'), list_name=dict(required=True, type='str'), attributes=dict(required=False, type='dict')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False ) 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'] timeout = input_params['timeout'] vfid = input_params['vfid'] module_name = str_to_human(input_params['module_name']) list_name = str_to_human(input_params['list_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, timeout) if ret_code != 0: module.exit_json(**result) facts = {} facts['ssh_hostkeymust'] = ssh_hostkeymust 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: result["list_get"] = ret_code exit_after_login(fos_ip_addr, https, auth, result, module, timeout) obj_list = response["Response"][str_to_yang(list_name)] if not isinstance(obj_list, list): if obj_list is None: obj_list = [] else: obj_list = [obj_list] to_human_list(module_name, list_name, obj_list, result) result["obj_list"] = obj_list ret_dict = {} ret_list = [] for obj in obj_list: if attributes == None: ret_list.append(obj) else: matched_all = 0 for k, v in attributes.items(): if k in obj and obj[k] == v: matched_all = matched_all + 1 if matched_all == len(attributes.items()): ret_list.append(obj) if attributes == None: result["attributes_len"] = 0 else: result["attributes_len"] = len(attributes.items()) result["ret_list"] = ret_list ret_dict[list_name] = ret_list result["ansible_facts"] = ret_dict 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', no_log=True), vfid=dict(required=False, type='int'), throttle=dict(required=False, type='float'), timeout=dict(required=False, type='float'), module_name=dict(required=True, type='str'), obj_name=dict(required=True, type='str')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False ) 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'] timeout = input_params['timeout'] vfid = input_params['vfid'] module_name = str_to_human(input_params['module_name']) obj_name = str_to_human(input_params['obj_name']) 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, timeout) if ret_code != 0: module.exit_json(**result) facts = {} facts['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: result["singleton_get"] = ret_code exit_after_login(fos_ip_addr, https, auth, result, module, timeout) obj = response["Response"][str_to_yang(obj_name)] to_human_singleton(module_name, obj_name, obj) result["obj"] = obj ret_dict = {} ret_dict[obj_name] = obj result["ansible_facts"] = ret_dict logout(fos_ip_addr, https, auth, result, timeout) module.exit_json(**result)