community.general/plugins/modules/network/cnos/cnos_facts.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# (C) 2019 Red Hat Inc.
# Copyright (C) 2019 Lenovo.
#
# GNU General Public License v3.0+
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Module to Collect facts from Lenovo Switches running Lenovo CNOS commands
# Lenovo Networking
#
from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}

DOCUMENTATION = '''
---
module: cnos_facts
author: "Anil Kumar Muraleedharan (@amuraleedhar)"
short_description: Collect facts from remote devices running Lenovo CNOS
description:
  - Collects a base set of device facts from a remote Lenovo device
    running on CNOS.  This module prepends all of the
    base network fact keys with C(ansible_net_<fact>).  The facts
    module will always collect a base set of facts from the device
    and can enable or disable collection of additional facts.
notes:
  - Tested against CNOS 10.8.1
options:
  authorize:
    description:
      - Instructs the module to enter privileged mode on the remote device
        before sending any commands.  If not specified, the device will
        attempt to execute all commands in non-privileged mode. If the value
        is not specified in the task, the value of environment variable
        C(ANSIBLE_NET_AUTHORIZE) will be used instead.
    type: bool
    default: 'no'
  auth_pass:
    description:
      - Specifies the password to use if required to enter privileged mode
        on the remote device.  If I(authorize) is false, then this argument
        does nothing. If the value is not specified in the task, the value of
        environment variable C(ANSIBLE_NET_AUTH_PASS) will be used instead.
  gather_subset:
    description:
      - When supplied, this argument will restrict the facts collected
        to a given subset.  Possible values for this argument include
        all, hardware, config, and interfaces.  Can specify a list of
        values to include a larger subset.  Values can also be used
        with an initial C(M(!)) to specify that a specific subset should
        not be collected.
    required: false
    default: '!config'
'''
EXAMPLES = '''
Tasks: The following are examples of using the module cnos_facts.
---
- name: Test cnos Facts
  cnos_facts:

---
# Collect all facts from the device
- cnos_facts:
    gather_subset: all

# Collect only the config and default facts
- cnos_facts:
    gather_subset:
      - config

# Do not collect hardware facts
- cnos_facts:
    gather_subset:
      - "!hardware"
'''
RETURN = '''
  ansible_net_gather_subset:
    description: The list of fact subsets collected from the device
    returned: always
    type: list
# default
  ansible_net_model:
    description: The model name returned from the Lenovo CNOS device
    returned: always
    type: str
  ansible_net_serialnum:
    description: The serial number of the Lenovo CNOS device
    returned: always
    type: str
  ansible_net_version:
    description: The CNOS operating system version running on the remote device
    returned: always
    type: str
  ansible_net_hostname:
    description: The configured hostname of the device
    returned: always
    type: str
  ansible_net_image:
    description: Indicates the active image for the device
    returned: always
    type: str
# hardware
  ansible_net_memfree_mb:
    description: The available free memory on the remote device in MB
    returned: when hardware is configured
    type: int
# config
  ansible_net_config:
    description: The current active config from the device
    returned: when config is configured
    type: str
# interfaces
  ansible_net_all_ipv4_addresses:
    description: All IPv4 addresses configured on the device
    returned: when interfaces is configured
    type: list
  ansible_net_all_ipv6_addresses:
    description: All IPv6 addresses configured on the device
    returned: when interfaces is configured
    type: list
  ansible_net_interfaces:
    description: A hash of all interfaces running on the system.
      This gives information on description, mac address, mtu, speed,
      duplex and operstatus
    returned: when interfaces is configured
    type: dict
  ansible_net_neighbors:
    description: The list of LLDP neighbors from the remote device
    returned: when interfaces is configured
    type: dict
'''

import re

from ansible_collections.community.general.plugins.module_utils.network.cnos.cnos import run_commands
from ansible_collections.community.general.plugins.module_utils.network.cnos.cnos import check_args
from ansible.module_utils._text import to_text
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.six import iteritems
from ansible.module_utils.six.moves import zip


class FactsBase(object):

    COMMANDS = list()

    def __init__(self, module):
        self.module = module
        self.facts = dict()
        self.responses = None
        self.PERSISTENT_COMMAND_TIMEOUT = 60

    def populate(self):
        self.responses = run_commands(self.module, self.COMMANDS,
                                      check_rc=False)

    def run(self, cmd):
        return run_commands(self.module, cmd, check_rc=False)


class Default(FactsBase):

    COMMANDS = ['show sys-info', 'show running-config']

    def populate(self):
        super(Default, self).populate()
        data = self.responses[0]
        data_run = self.responses[1]
        if data:
            self.facts['version'] = self.parse_version(data)
            self.facts['serialnum'] = self.parse_serialnum(data)
            self.facts['model'] = self.parse_model(data)
            self.facts['image'] = self.parse_image(data)
        if data_run:
            self.facts['hostname'] = self.parse_hostname(data_run)

    def parse_version(self, data):
        for line in data.split('\n'):
            line = line.strip()
            match = re.match(r'System Software Revision (.*?)',
                             line, re.M | re.I)
            if match:
                vers = line.split(':')
                ver = vers[1].strip()
                return ver
        return "NA"

    def parse_hostname(self, data_run):
        for line in data_run.split('\n'):
            line = line.strip()
            match = re.match(r'hostname (.*?)', line, re.M | re.I)
            if match:
                hosts = line.split()
                hostname = hosts[1].strip('\"')
                return hostname
        return "NA"

    def parse_model(self, data):
        for line in data.split('\n'):
            line = line.strip()
            match = re.match(r'System Model (.*?)', line, re.M | re.I)
            if match:
                mdls = line.split(':')
                mdl = mdls[1].strip()
                return mdl
        return "NA"

    def parse_image(self, data):
        match = re.search(r'(.*) image(.*)', data, re.M | re.I)
        if match:
            return "Image1"
        else:
            return "Image2"

    def parse_serialnum(self, data):
        for line in data.split('\n'):
            line = line.strip()
            match = re.match(r'System Serial Number (.*?)', line, re.M | re.I)
            if match:
                serNums = line.split(':')
                ser = serNums[1].strip()
                return ser
        return "NA"


class Hardware(FactsBase):

    COMMANDS = [
        'show running-config'
    ]

    def populate(self):
        super(Hardware, self).populate()
        data = self.run(['show process memory'])
        data = to_text(data, errors='surrogate_or_strict').strip()
        data = data.replace(r"\n", "\n")
        if data:
            for line in data.split('\n'):
                line = line.strip()
                match = re.match(r'Mem: (.*?)', line, re.M | re.I)
                if match:
                    memline = line.split(':')
                    mems = memline[1].strip().split()
                    self.facts['memtotal_mb'] = int(mems[0]) / 1024
                    self.facts['memused_mb'] = int(mems[1]) / 1024
                    self.facts['memfree_mb'] = int(mems[2]) / 1024
                    self.facts['memshared_mb'] = int(mems[3]) / 1024
                    self.facts['memavailable_mb'] = int(mems[5]) / 1024

    def parse_memtotal(self, data):
        match = re.search(r'^MemTotal:\s*(.*) kB', data, re.M | re.I)
        if match:
            return int(match.group(1)) / 1024

    def parse_memfree(self, data):
        match = re.search(r'^MemFree:\s*(.*) kB', data, re.M | re.I)
        if match:
            return int(match.group(1)) / 1024


class Config(FactsBase):

    COMMANDS = ['show running-config']

    def populate(self):
        super(Config, self).populate()
        data = self.responses[0]
        if data:
            self.facts['config'] = data


class Interfaces(FactsBase):

    COMMANDS = ['show interface brief']

    def populate(self):
        super(Interfaces, self).populate()

        self.facts['all_ipv4_addresses'] = list()
        self.facts['all_ipv6_addresses'] = list()

        data1 = self.run(['show interface status'])
        data1 = to_text(data1, errors='surrogate_or_strict').strip()
        data1 = data1.replace(r"\n", "\n")
        data2 = self.run(['show interface mac-address'])
        data2 = to_text(data2, errors='surrogate_or_strict').strip()
        data2 = data2.replace(r"\n", "\n")
        lines1 = None
        lines2 = None
        if data1:
            lines1 = self.parse_interfaces(data1)
        if data2:
            lines2 = self.parse_interfaces(data2)
        if lines1 is not None and lines2 is not None:
            self.facts['interfaces'] = self.populate_interfaces(lines1, lines2)
        data3 = self.run(['show lldp neighbors'])
        data3 = to_text(data3, errors='surrogate_or_strict').strip()
        data3 = data3.replace(r"\n", "\n")
        if data3:
            lines3 = self.parse_neighbors(data3)
        if lines3 is not None:
            self.facts['neighbors'] = self.populate_neighbors(lines3)

        data4 = self.run(['show ip interface brief vrf all'])
        data5 = self.run(['show ipv6 interface brief vrf all'])
        data4 = to_text(data4, errors='surrogate_or_strict').strip()
        data4 = data4.replace(r"\n", "\n")
        data5 = to_text(data5, errors='surrogate_or_strict').strip()
        data5 = data5.replace(r"\n", "\n")
        lines4 = None
        lines5 = None
        if data4:
            lines4 = self.parse_ipaddresses(data4)
            ipv4_interfaces = self.set_ip_interfaces(lines4)
            self.facts['all_ipv4_addresses'] = ipv4_interfaces
        if data5:
            lines5 = self.parse_ipaddresses(data5)
            ipv6_interfaces = self.set_ipv6_interfaces(lines5)
            self.facts['all_ipv6_addresses'] = ipv6_interfaces

    def parse_ipaddresses(self, data):
        parsed = list()
        for line in data.split('\n'):
            if len(line) == 0:
                continue
            else:
                line = line.strip()
                match = re.match(r'^(Ethernet+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
                match = re.match(r'^(po+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
                match = re.match(r'^(mgmt+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
                match = re.match(r'^(loopback+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
        return parsed

    def populate_interfaces(self, lines1, lines2):
        interfaces = dict()
        for line1, line2 in zip(lines1, lines2):
            line = line1 + "  " + line2
            intfSplit = line.split()
            innerData = dict()
            innerData['description'] = intfSplit[1].strip()
            innerData['macaddress'] = intfSplit[8].strip()
            innerData['type'] = intfSplit[6].strip()
            innerData['speed'] = intfSplit[5].strip()
            innerData['duplex'] = intfSplit[4].strip()
            innerData['operstatus'] = intfSplit[2].strip()
            interfaces[intfSplit[0].strip()] = innerData
        return interfaces

    def parse_interfaces(self, data):
        parsed = list()
        for line in data.split('\n'):
            if len(line) == 0:
                continue
            else:
                line = line.strip()
                match = re.match(r'^(Ethernet+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
                match = re.match(r'^(po+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
                match = re.match(r'^(mgmt+)', line)
                if match:
                    key = match.group(1)
                    parsed.append(line)
        return parsed

    def set_ip_interfaces(self, line4):
        ipv4_addresses = list()
        for line in line4:
            ipv4Split = line.split()
            if 'Ethernet' in ipv4Split[0]:
                ipv4_addresses.append(ipv4Split[1])
            if 'mgmt' in ipv4Split[0]:
                ipv4_addresses.append(ipv4Split[1])
            if 'po' in ipv4Split[0]:
                ipv4_addresses.append(ipv4Split[1])
            if 'loopback' in ipv4Split[0]:
                ipv4_addresses.append(ipv4Split[1])
        return ipv4_addresses

    def set_ipv6_interfaces(self, line4):
        ipv6_addresses = list()
        for line in line4:
            ipv6Split = line.split()
            if 'Ethernet' in ipv6Split[0]:
                ipv6_addresses.append(ipv6Split[1])
            if 'mgmt' in ipv6Split[0]:
                ipv6_addresses.append(ipv6Split[1])
            if 'po' in ipv6Split[0]:
                ipv6_addresses.append(ipv6Split[1])
            if 'loopback' in ipv6Split[0]:
                ipv6_addresses.append(ipv6Split[1])
        return ipv6_addresses

    def populate_neighbors(self, lines3):
        neighbors = dict()
        device_name = ''
        for line in lines3:
            neighborSplit = line.split()
            innerData = dict()
            count = len(neighborSplit)
            if count == 5:
                local_interface = neighborSplit[1].strip()
                innerData['Device Name'] = neighborSplit[0].strip()
                innerData['Hold Time'] = neighborSplit[2].strip()
                innerData['Capability'] = neighborSplit[3].strip()
                innerData['Remote Port'] = neighborSplit[4].strip()
                neighbors[local_interface] = innerData
            elif count == 4:
                local_interface = neighborSplit[0].strip()
                innerData['Hold Time'] = neighborSplit[1].strip()
                innerData['Capability'] = neighborSplit[2].strip()
                innerData['Remote Port'] = neighborSplit[3].strip()
                neighbors[local_interface] = innerData
        return neighbors

    def parse_neighbors(self, neighbors):
        parsed = list()
        for line in neighbors.split('\n'):
            if len(line) == 0:
                continue
            else:
                line = line.strip()
                if 'Ethernet' in line:
                    parsed.append(line)
                if 'mgmt' in line:
                    parsed.append(line)
                if 'po' in line:
                    parsed.append(line)
                if 'loopback' in line:
                    parsed.append(line)
        return parsed


FACT_SUBSETS = dict(
    default=Default,
    hardware=Hardware,
    interfaces=Interfaces,
    config=Config,
)

VALID_SUBSETS = frozenset(FACT_SUBSETS.keys())

PERSISTENT_COMMAND_TIMEOUT = 60


def main():
    """main entry point for module execution
    """
    argument_spec = dict(
        gather_subset=dict(default=['!config'], type='list')
    )

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

    gather_subset = module.params['gather_subset']

    runable_subsets = set()
    exclude_subsets = set()

    for subset in gather_subset:
        if subset == 'all':
            runable_subsets.update(VALID_SUBSETS)
            continue

        if subset.startswith('!'):
            subset = subset[1:]
            if subset == 'all':
                exclude_subsets.update(VALID_SUBSETS)
                continue
            exclude = True
        else:
            exclude = False

        if subset not in VALID_SUBSETS:
            module.fail_json(msg='Bad subset')

        if exclude:
            exclude_subsets.add(subset)
        else:
            runable_subsets.add(subset)

    if not runable_subsets:
        runable_subsets.update(VALID_SUBSETS)

    runable_subsets.difference_update(exclude_subsets)
    runable_subsets.add('default')

    facts = dict()
    facts['gather_subset'] = list(runable_subsets)

    instances = list()
    for key in runable_subsets:
        instances.append(FACT_SUBSETS[key](module))

    for inst in instances:
        inst.populate()
        facts.update(inst.facts)

    ansible_facts = dict()
    for key, value in iteritems(facts):
        key = 'ansible_net_%s' % key
        ansible_facts[key] = value

    warnings = list()
    check_args(module, warnings)

    module.exit_json(ansible_facts=ansible_facts, warnings=warnings)


if __name__ == '__main__':
    main()