Exemple #1
0
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)
Exemple #2
0
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'),
                         snmp_system=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']
    snmp_system = input_params['snmp_system']
    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 = 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)

    resp_system = response["Response"]["system"]

    to_human_system(resp_system)

    diff_attributes = generate_diff(result, resp_system, snmp_system)

    result["diff_attributes"] = diff_attributes
    result["resp_system"] = resp_system
    result["snmp_system"] = snmp_system

    if len(diff_attributes) > 0:
        ret_code = to_fos_system(diff_attributes, result)
        if ret_code != 0:
            exit_after_login(fos_ip_addr, https, auth, result, module)

        if not module.check_mode:
            ret_code = system_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)