����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

deexcl@216.73.217.71: ~ $ 
from __future__ import absolute_import, division, print_function


__metaclass__ = type

# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)


DOCUMENTATION = """
module: nxos_hsrp
extends_documentation_fragment:
- cisco.nxos.nxos
short_description: Manages HSRP configuration on NX-OS switches.
description:
- Manages HSRP configuration on NX-OS switches.
version_added: 1.0.0
author:
- Jason Edelman (@jedelman8)
- Gabriele Gerbino (@GGabriele)
notes:
- Tested against NXOSv 7.3.(0)D1(1) on VIRL
- Unsupported for Cisco MDS
- HSRP feature needs to be enabled first on the system.
- SVIs must exist before using this module.
- Interface must be a L3 port before using this module.
- HSRP cannot be configured on loopback interfaces.
- MD5 authentication is only possible with HSRPv2 while it is ignored if HSRPv1 is
  used instead, while it will not raise any error. Here we allow MD5 authentication
  only with HSRPv2 in order to enforce better practice.
options:
  group:
    description:
    - HSRP group number.
    required: true
    type: str
  interface:
    description:
    - Full name of interface that is being managed for HSRP.
    required: true
    type: str
  version:
    description:
    - HSRP version.
    default: '1'
    choices:
    - '1'
    - '2'
    type: str
  priority:
    description:
    - HSRP priority or keyword 'default'.
    type: str
  preempt:
    description:
    - Enable/Disable preempt.
    choices:
    - enabled
    - disabled
    type: str
  vip:
    description:
    - HSRP virtual IP address or keyword 'default'
    type: str
  auth_string:
    description:
    - Authentication string. If this needs to be hidden(for md5 type), the string
      should be 7 followed by the key string. Otherwise, it can be 0 followed by key
      string or just key string (for backward compatibility). For text type, this
      should be just be a key string. if this is 'default', authentication is removed.
    type: str
  auth_type:
    description:
    - Authentication type.
    choices:
    - text
    - md5
    type: str
  state:
    description:
    - Specify desired state of the resource.
    choices:
    - present
    - absent
    default: present
    type: str
"""

EXAMPLES = """
- name: Ensure HSRP is configured with following params on a SVI
  cisco.nxos.nxos_hsrp:
    group: 10
    vip: 10.1.1.1
    priority: 150
    interface: vlan10
    preempt: enabled

- name: Ensure HSRP is configured with following params on a SVI with clear text authentication
  cisco.nxos.nxos_hsrp:
    group: 10
    vip: 10.1.1.1
    priority: 150
    interface: vlan10
    preempt: enabled
    auth_type: text
    auth_string: CISCO

- name: Ensure HSRP is configured with md5 authentication and clear authentication
    string
  cisco.nxos.nxos_hsrp:
    group: 10
    vip: 10.1.1.1
    priority: 150
    interface: vlan10
    preempt: enabled
    auth_type: md5
    auth_string: 0 1234

- name: Ensure HSRP is configured with md5 authentication and hidden authentication
    string
  cisco.nxos.nxos_hsrp:
    group: 10
    vip: 10.1.1.1
    priority: 150
    interface: vlan10
    preempt: enabled
    auth_type: md5
    auth_string: 7 1234

- name: Remove HSRP config for given interface, group, and VIP
  cisco.nxos.nxos_hsrp:
    group: 10
    interface: vlan10
    vip: 10.1.1.1
    state: absent
"""

RETURN = r"""
commands:
    description: commands sent to the device
    returned: always
    type: list
    sample: ["interface vlan10", "hsrp version 2", "hsrp 30", "ip 10.30.1.1"]
"""

from ansible.module_utils.basic import AnsibleModule

from ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.nxos import (
    get_capabilities,
    get_interface_type,
    load_config,
    run_commands,
)


PARAM_TO_DEFAULT_KEYMAP = {
    "vip": None,
    "priority": "100",
    "auth_type": "text",
    "auth_string": "cisco",
}


def apply_key_map(key_map, table):
    new_dict = {}
    for key in table:
        new_key = key_map.get(key)
        if new_key:
            value = table.get(key)
            if value:
                new_dict[new_key] = str(value)
            else:
                new_dict[new_key] = value
    return new_dict


def get_interface_mode(interface, intf_type, module):
    command = "show interface {0} | json".format(interface)
    interface = {}
    mode = "unknown"
    try:
        body = run_commands(module, [command])[0]
    except IndexError:
        return None

    if intf_type in ["ethernet", "portchannel"]:
        interface_table = body["TABLE_interface"]["ROW_interface"]
        mode = str(interface_table.get("eth_mode", "layer3"))
        if mode == "access" or mode == "trunk":
            mode = "layer2"
    elif intf_type == "svi":
        mode = "layer3"
    return mode


def get_hsrp_group(group, interface, module):
    command = "show hsrp group {0} all | json".format(group)
    hsrp = {}

    hsrp_key = {
        "sh_if_index": "interface",
        "sh_group_num": "group",
        "sh_group_version": "version",
        "sh_cfg_prio": "priority",
        "sh_preempt": "preempt",
        "sh_vip": "vip",
        "sh_authentication_type": "auth_type",
        "sh_keystring_attr": "auth_enc",
        "sh_authentication_data": "auth_string",
    }

    try:
        body = run_commands(module, [command])[0]
        hsrp_table = body["TABLE_grp_detail"]["ROW_grp_detail"]
        if "sh_keystring_attr" not in hsrp_table:
            del hsrp_key["sh_keystring_attr"]
        if "unknown enum:" in str(hsrp_table):
            hsrp_table = get_hsrp_group_unknown_enum(module, command, hsrp_table)
    except (AttributeError, IndexError, TypeError, KeyError):
        return {}

    if isinstance(hsrp_table, dict):
        hsrp_table = [hsrp_table]

    for hsrp_group in hsrp_table:
        parsed_hsrp = apply_key_map(hsrp_key, hsrp_group)

        parsed_hsrp["interface"] = parsed_hsrp["interface"].lower()

        if parsed_hsrp["version"] == "v1":
            parsed_hsrp["version"] = "1"
        elif parsed_hsrp["version"] == "v2":
            parsed_hsrp["version"] = "2"

        if parsed_hsrp["auth_type"] == "md5":
            if parsed_hsrp["auth_enc"] == "hidden":
                parsed_hsrp["auth_enc"] = "7"
            else:
                parsed_hsrp["auth_enc"] = "0"

        if parsed_hsrp["interface"] == interface:
            return parsed_hsrp

    return hsrp


def get_hsrp_group_unknown_enum(module, command, hsrp_table):
    """Some older NXOS images fail to set the attr values when using structured output and
    instead set the values to <unknown enum>. This fallback method is a workaround that
    uses an unstructured (text) request to query the device a second time.
    'sh_preempt' is currently the only attr affected. Add checks for other attrs as needed.
    """
    if "unknown enum:" in hsrp_table["sh_preempt"]:
        cmd = {"output": "text", "command": command.split("|")[0]}
        out = run_commands(module, cmd)[0]
        hsrp_table["sh_preempt"] = "enabled" if ("may preempt" in out) else "disabled"
    return hsrp_table


def get_commands_remove_hsrp(group, interface):
    commands = ["interface {0}".format(interface), "no hsrp {0}".format(group)]
    return commands


def get_commands_config_hsrp(delta, interface, args, existing):
    commands = []

    config_args = {
        "group": "hsrp {group}",
        "priority": "{priority}",
        "preempt": "{preempt}",
        "vip": "{vip}",
    }

    preempt = delta.get("preempt", None)
    group = delta.get("group", None)
    vip = delta.get("vip", None)
    priority = delta.get("priority", None)

    if preempt:
        if preempt == "enabled":
            delta["preempt"] = "preempt"
        elif preempt == "disabled":
            delta["preempt"] = "no preempt"

    if priority:
        if priority == "default":
            if existing and existing.get("priority") != PARAM_TO_DEFAULT_KEYMAP.get("priority"):
                delta["priority"] = "no priority"
            else:
                del delta["priority"]
        else:
            delta["priority"] = "priority {0}".format(delta["priority"])

    if vip:
        if vip == "default":
            if existing and existing.get("vip") != PARAM_TO_DEFAULT_KEYMAP.get("vip"):
                delta["vip"] = "no ip"
            else:
                del delta["vip"]
        else:
            delta["vip"] = "ip {0}".format(delta["vip"])

    for key in delta:
        command = config_args.get(key, "DNE").format(**delta)
        if command and command != "DNE":
            if key == "group":
                commands.insert(0, command)
            else:
                commands.append(command)
        command = None

    auth_type = delta.get("auth_type", None)
    auth_string = delta.get("auth_string", None)
    auth_enc = delta.get("auth_enc", None)
    if auth_type or auth_string:
        if not auth_type:
            auth_type = args["auth_type"]
        elif not auth_string:
            auth_string = args["auth_string"]
        if auth_string != "default":
            if auth_type == "md5":
                command = "authentication md5 key-string {0} {1}".format(auth_enc, auth_string)
                commands.append(command)
            elif auth_type == "text":
                command = "authentication text {0}".format(auth_string)
                commands.append(command)
        else:
            if existing and existing.get("auth_string") != PARAM_TO_DEFAULT_KEYMAP.get(
                "auth_string",
            ):
                commands.append("no authentication")

    if commands and not group:
        commands.insert(0, "hsrp {0}".format(args["group"]))

    version = delta.get("version", None)
    if version:
        if version == "2":
            command = "hsrp version 2"
        elif version == "1":
            command = "hsrp version 1"
        commands.insert(0, command)
        commands.insert(0, "interface {0}".format(interface))

    if commands:
        if not commands[0].startswith("interface"):
            commands.insert(0, "interface {0}".format(interface))

    return commands


def is_default(interface, module):
    command = "show run interface {0}".format(interface)

    try:
        body = run_commands(module, [command], check_rc=False)[0]
        if "invalid" in body.lower():
            return "DNE"
        else:
            raw_list = body.split("\n")
            if raw_list[-1].startswith("interface"):
                return True
            else:
                return False
    except KeyError:
        return "DNE"


def validate_config(body, vip, module):
    new_body = "".join(body)
    if "invalid ip address" in new_body.lower():
        module.fail_json(msg="Invalid VIP. Possible duplicate IP address.", vip=vip)


def main():
    argument_spec = dict(
        group=dict(required=True, type="str"),
        interface=dict(required=True),
        version=dict(choices=["1", "2"], default="1", required=False),
        priority=dict(type="str", required=False),
        preempt=dict(type="str", choices=["disabled", "enabled"], required=False),
        vip=dict(type="str", required=False),
        auth_type=dict(choices=["text", "md5"], required=False),
        auth_string=dict(type="str", required=False),
        state=dict(choices=["absent", "present"], required=False, default="present"),
    )

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)

    warnings = list()
    results = dict(changed=False, warnings=warnings)

    interface = module.params["interface"].lower()
    group = module.params["group"]
    version = module.params["version"]
    state = module.params["state"]
    priority = module.params["priority"]
    preempt = module.params["preempt"]
    vip = module.params["vip"]
    auth_type = module.params["auth_type"]
    auth_full_string = module.params["auth_string"]
    auth_enc = "0"
    auth_string = None
    if auth_full_string:
        kstr = auth_full_string.split()
        if len(kstr) == 2:
            auth_enc = kstr[0]
            auth_string = kstr[1]
        elif len(kstr) == 1:
            auth_string = kstr[0]
        else:
            module.fail_json(msg="Invalid auth_string")
        if auth_enc != "0" and auth_enc != "7":
            module.fail_json(msg="Invalid auth_string, only 0 or 7 allowed")

    device_info = get_capabilities(module)
    network_api = device_info.get("network_api", "nxapi")

    intf_type = get_interface_type(interface)
    if intf_type != "ethernet" and network_api == "cliconf":
        if is_default(interface, module) == "DNE":
            module.fail_json(
                msg="That interface does not exist yet. Create " "it first.",
                interface=interface,
            )
        if intf_type == "loopback":
            module.fail_json(
                msg="Loopback interfaces don't support HSRP.",
                interface=interface,
            )

    mode = get_interface_mode(interface, intf_type, module)
    if mode == "layer2":
        module.fail_json(
            msg="That interface is a layer2 port.\nMake it " "a layer 3 port first.",
            interface=interface,
        )

    if auth_type or auth_string:
        if not (auth_type and auth_string):
            module.fail_json(
                msg="When using auth parameters, you need BOTH " "auth_type AND auth_string.",
            )

    args = dict(
        group=group,
        version=version,
        priority=priority,
        preempt=preempt,
        vip=vip,
        auth_type=auth_type,
        auth_string=auth_string,
        auth_enc=auth_enc,
    )

    proposed = dict((k, v) for k, v in args.items() if v is not None)

    existing = get_hsrp_group(group, interface, module)

    # This will enforce better practice with md5 and hsrp version.
    if proposed.get("auth_type", None) == "md5":
        if proposed["version"] == "1":
            module.fail_json(msg="It's recommended to use HSRP v2 " "when auth_type=md5")

    elif not proposed.get("auth_type", None) and existing:
        if (proposed["version"] == "1" and existing["auth_type"] == "md5") and state == "present":
            module.fail_json(
                msg="Existing auth_type is md5. It's recommended " "to use HSRP v2 when using md5",
            )

    commands = []
    if state == "present":
        delta = dict(set(proposed.items()).difference(existing.items()))
        if delta:
            command = get_commands_config_hsrp(delta, interface, args, existing)
            commands.extend(command)

    elif state == "absent":
        if existing:
            command = get_commands_remove_hsrp(group, interface)
            commands.extend(command)

    if commands:
        if module.check_mode:
            module.exit_json(**results)
        else:
            load_config(module, commands)

            # validate IP
            if network_api == "cliconf" and state == "present":
                commands.insert(0, "config t")
                body = run_commands(module, commands)
                validate_config(body, vip, module)

            results["changed"] = True

            if "configure" in commands:
                commands.pop(0)

    results["commands"] = commands
    module.exit_json(**results)


if __name__ == "__main__":
    main()

Filemanager

DIR : / usr/ lib/ python3.9/ site-packages/ ansible_collections/ cisco/ nxos/ plugins/ modules/
Name Type Size Permission Actions
__pycache__ Folder 0755
storage Folder 0755
__init__.py File 0 B 0644
nxos_aaa_server.py File 10.19 KB 0644
nxos_aaa_server_host.py File 10.92 KB 0644
nxos_acl_interfaces.py File 10.21 KB 0644
nxos_acls.py File 28.71 KB 0644
nxos_banner.py File 6.44 KB 0644
nxos_bfd_global.py File 9.08 KB 0644
nxos_bfd_interfaces.py File 6.84 KB 0644
nxos_bgp.py File 25.3 KB 0644
nxos_bgp_address_family.py File 30.41 KB 0644
nxos_bgp_af.py File 31.01 KB 0644
nxos_bgp_global.py File 48.43 KB 0644
nxos_bgp_neighbor.py File 18.79 KB 0644
nxos_bgp_neighbor_address_family.py File 33.62 KB 0644
nxos_bgp_neighbor_af.py File 26.84 KB 0644
nxos_command.py File 7.41 KB 0644
nxos_config.py File 22.51 KB 0644
nxos_devicealias.py File 18.33 KB 0644
nxos_evpn_global.py File 2.62 KB 0644
nxos_evpn_vni.py File 9.44 KB 0644
nxos_facts.py File 8.52 KB 0644
nxos_feature.py File 9.21 KB 0644
nxos_file_copy.py File 17.39 KB 0644
nxos_gir.py File 11.5 KB 0644
nxos_gir_profile_management.py File 5.84 KB 0644
nxos_hostname.py File 5.63 KB 0644
nxos_hsrp.py File 15.02 KB 0644
nxos_hsrp_interfaces.py File 6.16 KB 0644
nxos_igmp.py File 4.49 KB 0644
nxos_igmp_interface.py File 21.88 KB 0644
nxos_igmp_snooping.py File 9.72 KB 0644
nxos_install_os.py File 21.07 KB 0644
nxos_interfaces.py File 13.69 KB 0644
nxos_l2_interfaces.py File 12.05 KB 0644
nxos_l3_interfaces.py File 15.12 KB 0644
nxos_lacp.py File 6.39 KB 0644
nxos_lacp_interfaces.py File 9.13 KB 0644
nxos_lag_interfaces.py File 8.66 KB 0644
nxos_lldp_global.py File 8.68 KB 0644
nxos_lldp_interfaces.py File 6.21 KB 0644
nxos_logging.py File 27.52 KB 0644
nxos_logging_global.py File 21.08 KB 0644
nxos_ntp.py File 12.98 KB 0644
nxos_ntp_auth.py File 9.17 KB 0644
nxos_ntp_global.py File 19.63 KB 0644
nxos_ntp_options.py File 4.53 KB 0644
nxos_nxapi.py File 14.01 KB 0644
nxos_ospf_interfaces.py File 43.32 KB 0644
nxos_ospfv2.py File 62.64 KB 0644
nxos_ospfv3.py File 53.01 KB 0644
nxos_overlay_global.py File 5.64 KB 0644
nxos_pim.py File 6.15 KB 0644
nxos_pim_interface.py File 19.74 KB 0644
nxos_pim_rp_address.py File 7.61 KB 0644
nxos_ping.py File 7.05 KB 0644
nxos_prefix_lists.py File 26.39 KB 0644
nxos_reboot.py File 2.24 KB 0644
nxos_rollback.py File 3.51 KB 0644
nxos_route_maps.py File 57.7 KB 0644
nxos_rpm.py File 12.29 KB 0644
nxos_snapshot.py File 12.17 KB 0644
nxos_snmp_community.py File 6.6 KB 0644
nxos_snmp_contact.py File 3.81 KB 0644
nxos_snmp_host.py File 15.1 KB 0644
nxos_snmp_location.py File 3.91 KB 0644
nxos_snmp_server.py File 50.27 KB 0644
nxos_snmp_traps.py File 7.97 KB 0644
nxos_snmp_user.py File 12.34 KB 0644
nxos_static_routes.py File 20.79 KB 0644
nxos_system.py File 12.77 KB 0644
nxos_telemetry.py File 8.98 KB 0644
nxos_udld.py File 7.09 KB 0644
nxos_udld_interface.py File 8.51 KB 0644
nxos_user.py File 15.37 KB 0644
nxos_vlans.py File 10.6 KB 0644
nxos_vpc.py File 15.59 KB 0644
nxos_vpc_interface.py File 9.92 KB 0644
nxos_vrf.py File 19.78 KB 0644
nxos_vrf_af.py File 7.71 KB 0644
nxos_vrf_interface.py File 7.37 KB 0644
nxos_vrrp.py File 12 KB 0644
nxos_vsan.py File 10.8 KB 0644
nxos_vtp_domain.py File 5.73 KB 0644
nxos_vtp_password.py File 7.8 KB 0644
nxos_vtp_version.py File 5.54 KB 0644
nxos_vxlan_vtep.py File 16.86 KB 0644
nxos_vxlan_vtep_vni.py File 15.7 KB 0644
nxos_zone_zoneset.py File 33.96 KB 0644