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