Initial commit

plugins/module_utils/network/exos/facts/facts.py

@@ -0,0 +1,61 @@
+#
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+"""
+The facts class for exos
+this file validates each subset of facts and selectively
+calls the appropriate facts gathering function
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+from ansible_collections.community.general.plugins.module_utils.network.exos.argspec.facts.facts import FactsArgs
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.facts.facts import FactsBase
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.lldp_global.lldp_global import Lldp_globalFacts
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.vlans.vlans import VlansFacts
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.legacy.base import Default, Hardware, Interfaces, Config
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.lldp_interfaces.lldp_interfaces import Lldp_interfacesFacts
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.l2_interfaces.l2_interfaces import L2_interfacesFacts
+
+FACT_LEGACY_SUBSETS = dict(
+    default=Default,
+    hardware=Hardware,
+    interfaces=Interfaces,
+    config=Config)
+
+FACT_RESOURCE_SUBSETS = dict(
+    lldp_global=Lldp_globalFacts,
+    vlans=VlansFacts,
+    lldp_interfaces=Lldp_interfacesFacts,
+    l2_interfaces=L2_interfacesFacts,
+)
+
+
+class Facts(FactsBase):
+    """ The fact class for exos
+    """
+
+    VALID_LEGACY_GATHER_SUBSETS = frozenset(FACT_LEGACY_SUBSETS.keys())
+    VALID_RESOURCE_SUBSETS = frozenset(FACT_RESOURCE_SUBSETS.keys())
+
+    def __init__(self, module):
+        super(Facts, self).__init__(module)
+
+    def get_facts(self, legacy_facts_type=None, resource_facts_type=None, data=None):
+        """ Collect the facts for exos
+
+        :param legacy_facts_type: List of legacy facts types
+        :param resource_facts_type: List of resource fact types
+        :param data: previously collected conf
+        :rtype: dict
+        :return: the facts gathered
+        """
+        if self.VALID_RESOURCE_SUBSETS:
+            self.get_network_resources_facts(FACT_RESOURCE_SUBSETS, resource_facts_type, data)
+
+        if self.VALID_LEGACY_GATHER_SUBSETS:
+            self.get_network_legacy_facts(FACT_LEGACY_SUBSETS, legacy_facts_type)
+
+        return self.ansible_facts, self._warnings

plugins/module_utils/network/exos/facts/l2_interfaces/l2_interfaces.py

@@ -0,0 +1,92 @@
+#
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+"""
+The exos l2_interfaces fact class
+It is in this file the configuration is collected from the device
+for a given resource, parsed, and the facts tree is populated
+based on the configuration.
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import re
+from copy import deepcopy
+
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common import utils
+from ansible_collections.community.general.plugins.module_utils.network.exos.argspec.l2_interfaces.l2_interfaces import L2_interfacesArgs
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class L2_interfacesFacts(object):
+    """ The exos l2_interfaces fact class
+    """
+    def __init__(self, module, subspec='config', options='options'):
+        self._module = module
+        self.argument_spec = L2_interfacesArgs.argument_spec
+        spec = deepcopy(self.argument_spec)
+        if subspec:
+            if options:
+                facts_argument_spec = spec[subspec][options]
+            else:
+                facts_argument_spec = spec[subspec]
+        else:
+            facts_argument_spec = spec
+
+        self.generated_spec = utils.generate_dict(facts_argument_spec)
+
+    def populate_facts(self, connection, ansible_facts, data=None):
+        """ Populate the facts for l2_interfaces
+        :param connection: the device connection
+        :param ansible_facts: Facts dictionary
+        :param data: previously collected conf
+        :rtype: dictionary
+        :returns: facts
+        """
+
+        if not data:
+            request = [{
+                "path": "/rest/restconf/data/openconfig-interfaces:interfaces",
+                "method": "GET"
+            }]
+            data = send_requests(self._module, requests=request)
+
+        objs = []
+        if data:
+            for d in data[0]["openconfig-interfaces:interfaces"]["interface"]:
+                obj = self.render_config(self.generated_spec, d)
+                if obj:
+                    objs.append(obj)
+
+        ansible_facts['ansible_network_resources'].pop('l2_interfaces', None)
+        facts = {}
+        if objs:
+            params = utils.validate_config(self.argument_spec, {'config': objs})
+            facts['l2_interfaces'] = params['config']
+
+        ansible_facts['ansible_network_resources'].update(facts)
+        return ansible_facts
+
+    def render_config(self, spec, conf):
+        """
+        Render config as dictionary structure and delete keys
+          from spec for null values
+
+        :param spec: The facts tree, generated from the argspec
+        :param conf: The configuration
+        :rtype: dictionary
+        :returns: The generated config
+        """
+        config = deepcopy(spec)
+        if conf["config"]["type"] == "ethernetCsmacd":
+            conf_dict = conf["openconfig-if-ethernet:ethernet"]["openconfig-vlan:switched-vlan"]["config"]
+            config["name"] = conf["name"]
+            if conf_dict["interface-mode"] == "ACCESS":
+                config["access"]["vlan"] = conf_dict.get("access-vlan")
+            else:
+                if 'native-vlan' in conf_dict:
+                    config["trunk"]["native_vlan"] = conf_dict.get("native-vlan")
+                config["trunk"]["trunk_allowed_vlans"] = conf_dict.get("trunk-vlans")
+        return utils.remove_empties(config)

plugins/module_utils/network/exos/facts/legacy/base.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""
+The exos legacy fact class
+It is in this file the configuration is collected from the device
+for a given resource, parsed, and the facts tree is populated
+based on the configuration.
+"""
+
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+
+import re
+import json
+
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import run_commands
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.six import iteritems
+
+
+class FactsBase(object):
+
+    COMMANDS = list()
+
+    def __init__(self, module):
+        self.module = module
+        self.facts = dict()
+        self.warnings = list()
+        self.responses = None
+
+    def populate(self):
+        self.responses = run_commands(self.module, self.COMMANDS)
+
+    def run(self, cmd):
+        return run_commands(self.module, cmd)
+
+
+class Default(FactsBase):
+
+    COMMANDS = [
+        'show version',
+        'show switch'
+    ]
+
+    def populate(self):
+        super(Default, self).populate()
+        data = self.responses[0]
+        if data:
+            self.facts['version'] = self.parse_version(data)
+            self.facts['serialnum'] = self.parse_serialnum(data)
+
+        data = self.responses[1]
+        if data:
+            self.facts['model'] = self.parse_model(data)
+            self.facts['hostname'] = self.parse_hostname(data)
+
+    def parse_version(self, data):
+        match = re.search(r'Image\s+: ExtremeXOS version (\S+)', data)
+        if match:
+            return match.group(1)
+
+    def parse_model(self, data):
+        match = re.search(r'System Type:\s+(.*$)', data, re.M)
+        if match:
+            return match.group(1)
+
+    def parse_hostname(self, data):
+        match = re.search(r'SysName:\s+(\S+)', data, re.M)
+        if match:
+            return match.group(1)
+
+    def parse_serialnum(self, data):
+        match = re.search(r'Switch\s+: \S+ (\S+)', data, re.M)
+        if match:
+            return match.group(1)
+        # For stack, return serial number of the first switch in the stack.
+        match = re.search(r'Slot-\d+\s+: \S+ (\S+)', data, re.M)
+        if match:
+            return match.group(1)
+        # Handle unique formatting for VM
+        match = re.search(r'Switch\s+: PN:\S+\s+SN:(\S+)', data, re.M)
+        if match:
+            return match.group(1)
+
+
+class Hardware(FactsBase):
+
+    COMMANDS = [
+        'show memory'
+    ]
+
+    def populate(self):
+        super(Hardware, self).populate()
+        data = self.responses[0]
+        if data:
+            self.facts['memtotal_mb'] = int(round(int(self.parse_memtotal(data)) / 1024, 0))
+            self.facts['memfree_mb'] = int(round(int(self.parse_memfree(data)) / 1024, 0))
+
+    def parse_memtotal(self, data):
+        match = re.search(r' Total DRAM \(KB\): (\d+)', data, re.M)
+        if match:
+            return match.group(1)
+        # Handle unique formatting for VM
+        match = re.search(r' Total \s+\(KB\): (\d+)', data, re.M)
+        if match:
+            return match.group(1)
+
+    def parse_memfree(self, data):
+        match = re.search(r' Free\s+\(KB\): (\d+)', data, re.M)
+        if match:
+            return match.group(1)
+
+
+class Config(FactsBase):
+
+    COMMANDS = ['show configuration detail']
+
+    def populate(self):
+        super(Config, self).populate()
+        data = self.responses[0]
+        if data:
+            self.facts['config'] = data
+
+
+class Interfaces(FactsBase):
+
+    COMMANDS = [
+        'show switch',
+        {'command': 'show port config', 'output': 'json'},
+        {'command': 'show port description', 'output': 'json'},
+        {'command': 'show vlan detail', 'output': 'json'},
+        {'command': 'show lldp neighbors', 'output': 'json'}
+    ]
+
+    def populate(self):
+        super(Interfaces, self).populate()
+
+        self.facts['all_ipv4_addresses'] = list()
+        self.facts['all_ipv6_addresses'] = list()
+
+        data = self.responses[0]
+        if data:
+            sysmac = self.parse_sysmac(data)
+
+        data = self.responses[1]
+        if data:
+            self.facts['interfaces'] = self.populate_interfaces(data, sysmac)
+
+        data = self.responses[2]
+        if data:
+            self.populate_interface_descriptions(data)
+
+        data = self.responses[3]
+        if data:
+            self.populate_vlan_interfaces(data, sysmac)
+
+        data = self.responses[4]
+        if data:
+            self.facts['neighbors'] = self.parse_neighbors(data)
+
+    def parse_sysmac(self, data):
+        match = re.search(r'System MAC:\s+(\S+)', data, re.M)
+        if match:
+            return match.group(1)
+
+    def populate_interfaces(self, interfaces, sysmac):
+        facts = dict()
+        for elem in interfaces:
+            intf = dict()
+
+            if 'show_ports_config' not in elem:
+                continue
+
+            key = str(elem['show_ports_config']['port'])
+
+            if elem['show_ports_config']['linkState'] == 2:
+                # Link state is "not present", don't include
+                continue
+
+            intf['type'] = 'Ethernet'
+            intf['macaddress'] = sysmac
+            intf['bandwidth_configured'] = str(elem['show_ports_config']['speedCfg'])
+            intf['bandwidth'] = str(elem['show_ports_config']['speedActual'])
+            intf['duplex_configured'] = elem['show_ports_config']['duplexCfg']
+            intf['duplex'] = elem['show_ports_config']['duplexActual']
+            if elem['show_ports_config']['linkState'] == 1:
+                intf['lineprotocol'] = 'up'
+            else:
+                intf['lineprotocol'] = 'down'
+            if elem['show_ports_config']['portState'] == 1:
+                intf['operstatus'] = 'up'
+            else:
+                intf['operstatus'] = 'admin down'
+
+            facts[key] = intf
+        return facts
+
+    def populate_interface_descriptions(self, data):
+        for elem in data:
+            if 'show_ports_description' not in elem:
+                continue
+            key = str(elem['show_ports_description']['port'])
+
+            if 'descriptionString' in elem['show_ports_description']:
+                desc = elem['show_ports_description']['descriptionString']
+                self.facts['interfaces'][key]['description'] = desc
+
+    def populate_vlan_interfaces(self, data, sysmac):
+        for elem in data:
+            if 'vlanProc' in elem:
+                key = elem['vlanProc']['name1']
+                if key not in self.facts['interfaces']:
+                    intf = dict()
+                    intf['type'] = 'VLAN'
+                    intf['macaddress'] = sysmac
+                    self.facts['interfaces'][key] = intf
+
+                if elem['vlanProc']['ipAddress'] != '0.0.0.0':
+                    self.facts['interfaces'][key]['ipv4'] = list()
+                    addr = elem['vlanProc']['ipAddress']
+                    subnet = elem['vlanProc']['maskForDisplay']
+                    ipv4 = dict(address=addr, subnet=subnet)
+                    self.add_ip_address(addr, 'ipv4')
+                    self.facts['interfaces'][key]['ipv4'].append(ipv4)
+
+            if 'rtifIpv6Address' in elem:
+                key = elem['rtifIpv6Address']['rtifName']
+                if key not in self.facts['interfaces']:
+                    intf = dict()
+                    intf['type'] = 'VLAN'
+                    intf['macaddress'] = sysmac
+                    self.facts['interfaces'][key] = intf
+                self.facts['interfaces'][key]['ipv6'] = list()
+                addr, subnet = elem['rtifIpv6Address']['ipv6_address_mask'].split('/')
+                ipv6 = dict(address=addr, subnet=subnet)
+                self.add_ip_address(addr, 'ipv6')
+                self.facts['interfaces'][key]['ipv6'].append(ipv6)
+
+    def add_ip_address(self, address, family):
+        if family == 'ipv4':
+            if address not in self.facts['all_ipv4_addresses']:
+                self.facts['all_ipv4_addresses'].append(address)
+        else:
+            if address not in self.facts['all_ipv6_addresses']:
+                self.facts['all_ipv6_addresses'].append(address)
+
+    def parse_neighbors(self, data):
+        facts = dict()
+        for elem in data:
+            if 'lldpPortNbrInfoShort' not in elem:
+                continue
+            intf = str(elem['lldpPortNbrInfoShort']['port'])
+            if intf not in facts:
+                facts[intf] = list()
+            fact = dict()
+            fact['host'] = elem['lldpPortNbrInfoShort']['nbrSysName']
+            fact['port'] = str(elem['lldpPortNbrInfoShort']['nbrPortID'])
+            facts[intf].append(fact)
+        return facts

plugins/module_utils/network/exos/facts/lldp_global/lldp_global.py

@@ -0,0 +1,97 @@
+#
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+"""
+The exos lldp_global fact class
+It is in this file the configuration is collected from the device
+for a given resource, parsed, and the facts tree is populated
+based on the configuration.
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import re
+from copy import deepcopy
+
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common import utils
+from ansible_collections.community.general.plugins.module_utils.network.exos.argspec.lldp_global.lldp_global \
+    import Lldp_globalArgs
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class Lldp_globalFacts(object):
+    """ The exos lldp_global fact class
+    """
+
+    TLV_SELECT_OPTIONS = [
+        "SYSTEM_NAME",
+        "SYSTEM_DESCRIPTION",
+        "SYSTEM_CAPABILITIES",
+        "MANAGEMENT_ADDRESS",
+        "PORT_DESCRIPTION"]
+
+    def __init__(self, module, subspec='config', options='options'):
+        self._module = module
+        self.argument_spec = Lldp_globalArgs.argument_spec
+        spec = deepcopy(self.argument_spec)
+        if subspec:
+            if options:
+                facts_argument_spec = spec[subspec][options]
+            else:
+                facts_argument_spec = spec[subspec]
+        else:
+            facts_argument_spec = spec
+
+        self.generated_spec = utils.generate_dict(facts_argument_spec)
+
+    def populate_facts(self, connection, ansible_facts, data=None):
+        """ Populate the facts for lldp_global
+        :param connection: the device connection
+        :param ansible_facts: Facts dictionary
+        :param data: previously collected conf
+        :rtype: dictionary
+        :returns: facts
+        """
+        if not data:
+            request = {
+                "path": "/rest/restconf/data/openconfig-lldp:lldp/config/",
+                "method": "GET",
+            }
+            data = send_requests(self._module, request)
+
+        obj = {}
+        if data:
+            lldp_obj = self.render_config(self.generated_spec, data[0])
+            if lldp_obj:
+                obj = lldp_obj
+
+        ansible_facts['ansible_network_resources'].pop('lldp_global', None)
+        facts = {}
+
+        params = utils.validate_config(self.argument_spec, {'config': obj})
+        facts['lldp_global'] = params['config']
+
+        ansible_facts['ansible_network_resources'].update(facts)
+        return ansible_facts
+
+    def render_config(self, spec, conf):
+        """
+        Render config as dictionary structure and delete keys
+          from spec for null values
+
+        :param spec: The facts tree, generated from the argspec
+        :param conf: The configuration
+        :rtype: dictionary
+        :returns: The generated config
+        """
+        config = deepcopy(spec)
+        config['interval'] = conf["openconfig-lldp:config"]["hello-timer"]
+
+        for item in self.TLV_SELECT_OPTIONS:
+            config["tlv_select"][item.lower()] = (
+                False if (item in conf["openconfig-lldp:config"]["suppress-tlv-advertisement"])
+                else True)
+
+        return utils.remove_empties(config)

plugins/module_utils/network/exos/facts/lldp_interfaces/lldp_interfaces.py

@@ -0,0 +1,88 @@
+#
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+"""
+The exos lldp_interfaces fact class
+It is in this file the configuration is collected from the device
+for a given resource, parsed, and the facts tree is populated
+based on the configuration.
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import re
+from copy import deepcopy
+
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common import utils
+from ansible_collections.community.general.plugins.module_utils.network.exos.argspec.lldp_interfaces.lldp_interfaces import Lldp_interfacesArgs
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class Lldp_interfacesFacts(object):
+    """ The exos lldp_interfaces fact class
+    """
+
+    def __init__(self, module, subspec='config', options='options'):
+        self._module = module
+        self.argument_spec = Lldp_interfacesArgs.argument_spec
+        spec = deepcopy(self.argument_spec)
+        if subspec:
+            if options:
+                facts_argument_spec = spec[subspec][options]
+            else:
+                facts_argument_spec = spec[subspec]
+        else:
+            facts_argument_spec = spec
+
+        self.generated_spec = utils.generate_dict(facts_argument_spec)
+
+    def populate_facts(self, connection, ansible_facts, data=None):
+        """ Populate the facts for lldp_interfaces
+        :param connection: the device connection
+        :param ansible_facts: Facts dictionary
+        :param data: previously collected conf
+        :rtype: dictionary
+        :returns: facts
+        """
+
+        if not data:
+            request = [{
+                "path": "/rest/restconf/data/openconfig-lldp:lldp/interfaces?depth=4",
+                "method": "GET"
+            }]
+            data = send_requests(self._module, requests=request)
+
+        objs = []
+        if data:
+            for d in data[0]["openconfig-lldp:interfaces"]["interface"]:
+                obj = self.render_config(self.generated_spec, d["config"])
+                if obj:
+                    objs.append(obj)
+
+        ansible_facts['ansible_network_resources'].pop('lldp_interfaces', None)
+        facts = {}
+        if objs:
+            params = utils.validate_config(self.argument_spec, {'config': objs})
+            facts['lldp_interfaces'] = params['config']
+
+        ansible_facts['ansible_network_resources'].update(facts)
+        return ansible_facts
+
+    def render_config(self, spec, conf):
+        """
+        Render config as dictionary structure and delete keys
+          from spec for null values
+
+        :param spec: The facts tree, generated from the argspec
+        :param conf: The configuration
+        :rtype: dictionary
+        :returns: The generated config
+        """
+        config = deepcopy(spec)
+
+        config["name"] = conf["name"]
+        config["enabled"] = bool(conf["enabled"])
+
+        return utils.remove_empties(config)

plugins/module_utils/network/exos/facts/vlans/vlans.py

@@ -0,0 +1,89 @@
+#
+# -*- coding: utf-8 -*-
+# Copyright 2019 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+"""
+The exos vlans fact class
+It is in this file the configuration is collected from the device
+for a given resource, parsed, and the facts tree is populated
+based on the configuration.
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import re
+from copy import deepcopy
+
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common import utils
+from ansible_collections.community.general.plugins.module_utils.network.exos.argspec.vlans.vlans import VlansArgs
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class VlansFacts(object):
+    """ The exos vlans fact class
+    """
+
+    def __init__(self, module, subspec='config', options='options'):
+        self._module = module
+        self.argument_spec = VlansArgs.argument_spec
+        spec = deepcopy(self.argument_spec)
+        if subspec:
+            if options:
+                facts_argument_spec = spec[subspec][options]
+            else:
+                facts_argument_spec = spec[subspec]
+        else:
+            facts_argument_spec = spec
+
+        self.generated_spec = utils.generate_dict(facts_argument_spec)
+
+    def populate_facts(self, connection, ansible_facts, data=None):
+        """ Populate the facts for vlans
+        :param connection: the device connection
+        :param ansible_facts: Facts dictionary
+        :param data: previously collected conf
+        :rtype: dictionary
+        :returns: facts
+        """
+
+        if not data:
+            request = [{
+                "path": "/rest/restconf/data/openconfig-vlan:vlans?depth=5",
+                "method": "GET"
+            }]
+            data = send_requests(self._module, requests=request)
+
+        objs = []
+        if data:
+            for d in data[0]["openconfig-vlan:vlans"]["vlan"]:
+                obj = self.render_config(self.generated_spec, d["config"])
+                if obj:
+                    objs.append(obj)
+
+        ansible_facts['ansible_network_resources'].pop('vlans', None)
+        facts = {}
+        if objs:
+            params = utils.validate_config(self.argument_spec, {'config': objs})
+            facts['vlans'] = params['config']
+
+        ansible_facts['ansible_network_resources'].update(facts)
+        return ansible_facts
+
+    def render_config(self, spec, conf):
+        """
+        Render config as dictionary structure and delete keys
+          from spec for null values
+
+        :param spec: The facts tree, generated from the argspec
+        :param conf: The configuration
+        :rtype: dictionary
+        :returns: The generated config
+        """
+        config = deepcopy(spec)
+
+        config["name"] = conf["name"]
+        config["state"] = "suspend" if conf["status"] == "SUSPENDED" else conf["status"].lower()
+        config["vlan_id"] = conf["vlan-id"]
+
+        return utils.remove_empties(config)