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'),
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']
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)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
for area in valid_areas:
if (gather_subset is None or area in gather_subset
or "all" in gather_subset):
if area == "brocade_interface_fibrechannel":
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)
interface = {}
interface["fibrechannel"] = (
response["Response"]["fibrechannel"])
for port in interface["fibrechannel"]:
to_human_fc(port)
ret_code, response = fc_port_stats_get(fos_ip_addr, https,
auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
interface["fibrechannel-statistics"] = (
response["Response"]["fibrechannel-statistics"])
facts[area] = interface
if area == "brocade_zoning":
ret_code, response = defined_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
zoning = {}
zoning["defined-configuration"] = (
response["Response"]["defined-configuration"])
ret_code, response = effective_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
zoning["effective-configuration"] = (
response["Response"]["effective-configuration"])
to_human_zoning(zoning["effective-configuration"])
facts[area] = zoning
if area == "brocade_chassis":
ret_code, response = chassis_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_chassis(response["Response"]["chassis"])
facts[area] = response["Response"]["chassis"]
if area == "brocade_fibrechannel_configuration_fabric":
ret_code, response = fabric_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_fabric(response["Response"]["fabric"])
facts[area] = response["Response"]["fabric"]
if area == "brocade_fibrechannel_configuration_port_configuration":
ret_code, response = port_configuration_get(
fos_user_name, fos_password, fos_ip_addr, fos_version,
https, auth, vfid, result, ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_port_configuration(
response["Response"]["port-configuration"])
facts[area] = response["Response"]["port-configuration"]
if area == "brocade_fibrechannel_switch":
ret_code, response = fc_switch_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_switch(response["Response"]["fibrechannel-switch"])
facts[area] = response["Response"]["fibrechannel-switch"]
if area == "brocade_time_clock_server":
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)
to_human_clock_server(response["Response"]["clock-server"])
facts[area] = response["Response"]["clock-server"]
if area == "brocade_time_time_zone":
ret_code, response = time_zone_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_time_zone(response["Response"]["time-zone"])
facts[area] = response["Response"]["time-zone"]
if area == "brocade_logging_syslog_server":
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)
if isinstance(response["Response"]["syslog-server"], list):
servers = response["Response"]["syslog-server"]
else:
servers = [response["Response"]["syslog-server"]]
for server in servers:
to_human_syslog_server(server)
facts[area] = servers
if area == "brocade_logging_audit":
ret_code, response = audit_get(fos_ip_addr, https, auth, vfid,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_audit(response["Response"]["audit"])
facts[area] = response["Response"]["audit"]
if area == "brocade_snmp_system":
ret_code, response = system_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)
to_human_system(response["Response"]["system"])
facts[area] = response["Response"]["system"]
if area == "brocade_security_ipfilter_rule":
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)
for rule in response["Response"]["ipfilter-rule"]:
to_human_ipfilter_rule(rule)
facts[area] = response["Response"]["ipfilter-rule"]
if area == "brocade_security_ipfilter_policy":
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)
for rule in response["Response"]["ipfilter-policy"]:
to_human_ipfilter_policy(rule)
facts[area] = response["Response"]["ipfilter-policy"]
if area == "brocade_security_user_config":
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)
for rule in response["Response"]["user-config"]:
to_human_user_config(rule)
facts[area] = response["Response"]["user-config"]
result["ansible_facts"] = facts
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'),
wwn=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']
vfid = input_params['vfid']
wwn = input_params['wwn']
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)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = defined_get(fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
alias_list = []
if "alias" in response["Response"]["defined-configuration"]:
if isinstance(response["Response"]["defined-configuration"]["alias"],
list):
alias_list = response["Response"]["defined-configuration"]["alias"]
else:
alias_list = [
response["Response"]["defined-configuration"]["alias"]
]
result["alias_list"] = alias_list
ret_list = []
for alias in alias_list:
if "member-entry" in alias and "alias-entry-name" in alias[
"member-entry"]:
if isinstance(alias["member-entry"]["alias-entry-name"], list):
for entry in alias["member-entry"]["alias-entry-name"]:
if entry == wwn.lower():
ret_list.append(alias)
break
else:
if alias["member-entry"]["alias-entry-name"] == wwn.lower():
ret_list.append(alias)
ret_dict = {}
if len(ret_list) > 0:
ret_dict["alias"] = ret_list
result["ansible_facts"] = ret_dict
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'),
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)
