Initial commit

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

@@ -0,0 +1,294 @@
+#
+# -*- 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 class
+It is in this file where the current configuration (as dict)
+is compared to the provided configuration (as dict) and the command set
+necessary to bring the current configuration to it's desired end-state is
+created
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import json
+from copy import deepcopy
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base import ConfigBase
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list, dict_diff
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.facts import Facts
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class L2_interfaces(ConfigBase):
+    """
+    The exos_l2_interfaces class
+    """
+
+    gather_subset = [
+        '!all',
+        '!min',
+    ]
+
+    gather_network_resources = [
+        'l2_interfaces',
+    ]
+
+    L2_INTERFACE_NATIVE = {
+        "data": {
+            "openconfig-vlan:config": {
+                "interface-mode": "TRUNK",
+                "native-vlan": None,
+                "trunk-vlans": []
+            }
+        },
+        "method": "PATCH",
+        "path": None
+    }
+
+    L2_INTERFACE_TRUNK = {
+        "data": {
+            "openconfig-vlan:config": {
+                "interface-mode": "TRUNK",
+                "trunk-vlans": []
+            }
+        },
+        "method": "PATCH",
+        "path": None
+    }
+
+    L2_INTERFACE_ACCESS = {
+        "data": {
+            "openconfig-vlan:config": {
+                "interface-mode": "ACCESS",
+                "access-vlan": None
+            }
+        },
+        "method": "PATCH",
+        "path": None
+    }
+
+    L2_PATH = "/rest/restconf/data/openconfig-interfaces:interfaces/interface="
+
+    def __init__(self, module):
+        super(L2_interfaces, self).__init__(module)
+
+    def get_l2_interfaces_facts(self):
+        """ Get the 'facts' (the current configuration)
+
+        :rtype: A dictionary
+        :returns: The current configuration as a dictionary
+        """
+        facts, _warnings = Facts(self._module).get_facts(
+            self.gather_subset, self.gather_network_resources)
+        l2_interfaces_facts = facts['ansible_network_resources'].get(
+            'l2_interfaces')
+        if not l2_interfaces_facts:
+            return []
+        return l2_interfaces_facts
+
+    def execute_module(self):
+        """ Execute the module
+
+        :rtype: A dictionary
+        :returns: The result from module execution
+        """
+        result = {'changed': False}
+        warnings = list()
+        requests = list()
+
+        existing_l2_interfaces_facts = self.get_l2_interfaces_facts()
+        requests.extend(self.set_config(existing_l2_interfaces_facts))
+        if requests:
+            if not self._module.check_mode:
+                send_requests(self._module, requests=requests)
+            result['changed'] = True
+        result['requests'] = requests
+
+        changed_l2_interfaces_facts = self.get_l2_interfaces_facts()
+
+        result['before'] = existing_l2_interfaces_facts
+        if result['changed']:
+            result['after'] = changed_l2_interfaces_facts
+
+        result['warnings'] = warnings
+        return result
+
+    def set_config(self, existing_l2_interfaces_facts):
+        """ Collect the configuration from the args passed to the module,
+            collect the current configuration (as a dict from facts)
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        want = self._module.params['config']
+        have = existing_l2_interfaces_facts
+        resp = self.set_state(want, have)
+        return to_list(resp)
+
+    def set_state(self, want, have):
+        """ Select the appropriate function based on the state provided
+
+        :param want: the desired configuration as a dictionary
+        :param have: the current configuration as a dictionary
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        state = self._module.params['state']
+        if state == 'overridden':
+            requests = self._state_overridden(want, have)
+        elif state == 'deleted':
+            requests = self._state_deleted(want, have)
+        elif state == 'merged':
+            requests = self._state_merged(want, have)
+        elif state == 'replaced':
+            requests = self._state_replaced(want, have)
+        return requests
+
+    def _state_replaced(self, want, have):
+        """ The request generator when state is replaced
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        for w in want:
+            for h in have:
+                if w["name"] == h["name"]:
+                    if dict_diff(w, h):
+                        l2_request = self._update_patch_request(w, h)
+                        l2_request["data"] = json.dumps(l2_request["data"])
+                        requests.append(l2_request)
+                    break
+
+        return requests
+
+    def _state_overridden(self, want, have):
+        """ The request generator when state is overridden
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        have_copy = []
+        for w in want:
+            for h in have:
+                if w["name"] == h["name"]:
+                    if dict_diff(w, h):
+                        l2_request = self._update_patch_request(w, h)
+                        l2_request["data"] = json.dumps(l2_request["data"])
+                        requests.append(l2_request)
+                    have_copy.append(h)
+                    break
+
+        for h in have:
+            if h not in have_copy:
+                l2_delete = self._update_delete_request(h)
+                if l2_delete["path"]:
+                    l2_delete["data"] = json.dumps(l2_delete["data"])
+                    requests.append(l2_delete)
+
+        return requests
+
+    def _state_merged(self, want, have):
+        """ The request generator when state is merged
+
+        :rtype: A list
+        :returns: the requests necessary to merge the provided into
+                  the current configuration
+        """
+        requests = []
+        for w in want:
+            for h in have:
+                if w["name"] == h["name"]:
+                    if dict_diff(h, w):
+                        l2_request = self._update_patch_request(w, h)
+                        l2_request["data"] = json.dumps(l2_request["data"])
+                        requests.append(l2_request)
+                    break
+
+        return requests
+
+    def _state_deleted(self, want, have):
+        """ The request generator when state is deleted
+
+        :rtype: A list
+        :returns: the requests necessary to remove the current configuration
+                  of the provided objects
+        """
+        requests = []
+        if want:
+            for w in want:
+                for h in have:
+                    if w["name"] == h["name"]:
+                        l2_delete = self._update_delete_request(h)
+                        if l2_delete["path"]:
+                            l2_delete["data"] = json.dumps(l2_delete["data"])
+                            requests.append(l2_delete)
+                        break
+
+        else:
+            for h in have:
+                l2_delete = self._update_delete_request(h)
+                if l2_delete["path"]:
+                    l2_delete["data"] = json.dumps(l2_delete["data"])
+                    requests.append(l2_delete)
+
+        return requests
+
+    def _update_patch_request(self, want, have):
+
+        facts, _warnings = Facts(self._module).get_facts(
+            self.gather_subset, ['vlans', ])
+        vlans_facts = facts['ansible_network_resources'].get('vlans')
+
+        vlan_id = []
+
+        for vlan in vlans_facts:
+            vlan_id.append(vlan['vlan_id'])
+
+        if want.get("access"):
+            if want["access"]["vlan"] in vlan_id:
+                l2_request = deepcopy(self.L2_INTERFACE_ACCESS)
+                l2_request["data"]["openconfig-vlan:config"]["access-vlan"] = want["access"]["vlan"]
+                l2_request["path"] = self.L2_PATH + str(want["name"]) + "/openconfig-if-ethernet:ethernet/openconfig-vlan:switched-vlan/config"
+            else:
+                self._module.fail_json(msg="VLAN %s does not exist" % (want["access"]["vlan"]))
+
+        elif want.get("trunk"):
+            if want["trunk"]["native_vlan"]:
+                if want["trunk"]["native_vlan"] in vlan_id:
+                    l2_request = deepcopy(self.L2_INTERFACE_NATIVE)
+                    l2_request["data"]["openconfig-vlan:config"]["native-vlan"] = want["trunk"]["native_vlan"]
+                    l2_request["path"] = self.L2_PATH + str(want["name"]) + "/openconfig-if-ethernet:ethernet/openconfig-vlan:switched-vlan/config"
+                    for vlan in want["trunk"]["trunk_allowed_vlans"]:
+                        if int(vlan) in vlan_id:
+                            l2_request["data"]["openconfig-vlan:config"]["trunk-vlans"].append(int(vlan))
+                        else:
+                            self._module.fail_json(msg="VLAN %s does not exist" % (vlan))
+                else:
+                    self._module.fail_json(msg="VLAN %s does not exist" % (want["trunk"]["native_vlan"]))
+            else:
+                l2_request = deepcopy(self.L2_INTERFACE_TRUNK)
+                l2_request["path"] = self.L2_PATH + str(want["name"]) + "/openconfig-if-ethernet:ethernet/openconfig-vlan:switched-vlan/config"
+                for vlan in want["trunk"]["trunk_allowed_vlans"]:
+                    if int(vlan) in vlan_id:
+                        l2_request["data"]["openconfig-vlan:config"]["trunk-vlans"].append(int(vlan))
+                    else:
+                        self._module.fail_json(msg="VLAN %s does not exist" % (vlan))
+        return l2_request
+
+    def _update_delete_request(self, have):
+
+        l2_request = deepcopy(self.L2_INTERFACE_ACCESS)
+
+        if have["access"] and have["access"]["vlan"] != 1 or have["trunk"] or not have["access"]:
+            l2_request["data"]["openconfig-vlan:config"]["access-vlan"] = 1
+            l2_request["path"] = self.L2_PATH + str(have["name"]) + "/openconfig-if-ethernet:ethernet/openconfig-vlan:switched-vlan/config"
+
+        return l2_request

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

@@ -0,0 +1,199 @@
+#
+# -*- 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 class
+It is in this file where the current configuration (as dict)
+is compared to the provided configuration (as dict) and the command set
+necessary to bring the current configuration to it's desired end-state is
+created
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base import ConfigBase
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.facts import Facts
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+import json
+from copy import deepcopy
+
+
+class Lldp_global(ConfigBase):
+    """
+    The exos_lldp_global class
+    """
+
+    gather_subset = [
+        '!all',
+        '!min',
+    ]
+
+    gather_network_resources = [
+        'lldp_global',
+    ]
+
+    LLDP_DEFAULT_INTERVAL = 30
+    LLDP_DEFAULT_TLV = {
+        'system_name': True,
+        'system_description': True,
+        'system_capabilities': False,
+        'port_description': False,
+        'management_address': False
+    }
+    LLDP_REQUEST = {
+        "data": {"openconfig-lldp:config": {}},
+        "method": "PUT",
+        "path": "/rest/restconf/data/openconfig-lldp:lldp/config"
+    }
+
+    def __init__(self, module):
+        super(Lldp_global, self).__init__(module)
+
+    def get_lldp_global_facts(self):
+        """ Get the 'facts' (the current configuration)
+
+        :rtype: A dictionary
+        :returns: The current configuration as a dictionary
+        """
+        facts, _warnings = Facts(self._module).get_facts(
+            self.gather_subset, self.gather_network_resources)
+        lldp_global_facts = facts['ansible_network_resources'].get('lldp_global')
+        if not lldp_global_facts:
+            return {}
+        return lldp_global_facts
+
+    def execute_module(self):
+        """ Execute the module
+
+        :rtype: A dictionary
+        :returns: The result from module execution
+        """
+        result = {'changed': False}
+        warnings = list()
+        requests = list()
+
+        existing_lldp_global_facts = self.get_lldp_global_facts()
+        requests.extend(self.set_config(existing_lldp_global_facts))
+        if requests:
+            if not self._module.check_mode:
+                send_requests(self._module, requests)
+            result['changed'] = True
+        result['requests'] = requests
+
+        changed_lldp_global_facts = self.get_lldp_global_facts()
+
+        result['before'] = existing_lldp_global_facts
+        if result['changed']:
+            result['after'] = changed_lldp_global_facts
+
+        result['warnings'] = warnings
+        return result
+
+    def set_config(self, existing_lldp_global_facts):
+        """ Collect the configuration from the args passed to the module,
+            collect the current configuration (as a dict from facts)
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        want = self._module.params['config']
+        have = existing_lldp_global_facts
+        resp = self.set_state(want, have)
+        return to_list(resp)
+
+    def set_state(self, want, have):
+        """ Select the appropriate function based on the state provided
+
+        :param want: the desired configuration as a dictionary
+        :param have: the current configuration as a dictionary
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        state = self._module.params['state']
+
+        if state == 'deleted':
+            requests = self._state_deleted(want, have)
+        elif state == 'merged':
+            requests = self._state_merged(want, have)
+        elif state == 'replaced':
+            requests = self._state_replaced(want, have)
+
+        return requests
+
+    def _state_replaced(self, want, have):
+        """ The request generator when state is replaced
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        requests.extend(self._state_deleted(want, have))
+        requests.extend(self._state_merged(want, have))
+        return requests
+
+    def _state_merged(self, want, have):
+        """ The request generator when state is merged
+
+        :rtype: A list
+        :returns: the requests necessary to merge the provided into
+                  the current configuration
+        """
+        requests = []
+
+        request = deepcopy(self.LLDP_REQUEST)
+        self._update_lldp_config_body_if_diff(want, have, request)
+
+        if len(request["data"]["openconfig-lldp:config"]):
+            request["data"] = json.dumps(request["data"])
+            requests.append(request)
+
+        return requests
+
+    def _state_deleted(self, want, have):
+        """ The request generator when state is deleted
+
+        :rtype: A list
+        :returns: the requests necessary to remove the current configuration
+                  of the provided objects
+        """
+        requests = []
+
+        request = deepcopy(self.LLDP_REQUEST)
+        if want:
+            self._update_lldp_config_body_if_diff(want, have, request)
+        else:
+            if self.LLDP_DEFAULT_INTERVAL != have['interval']:
+                request["data"]["openconfig-lldp:config"].update(
+                    {"hello-timer": self.LLDP_DEFAULT_INTERVAL})
+
+            if have['tlv_select'] != self.LLDP_DEFAULT_TLV:
+                request["data"]["openconfig-lldp:config"].update(
+                    {"suppress-tlv-advertisement": [key.upper() for key, value in self.LLDP_DEFAULT_TLV.items() if not value]})
+                request["data"]["openconfig-lldp:config"]["suppress-tlv-advertisement"].sort()
+        if len(request["data"]["openconfig-lldp:config"]):
+            request["data"] = json.dumps(request["data"])
+            requests.append(request)
+
+        return requests
+
+    def _update_lldp_config_body_if_diff(self, want, have, request):
+        if want.get('interval'):
+            if want['interval'] != have['interval']:
+                request["data"]["openconfig-lldp:config"].update(
+                    {"hello-timer": want['interval']})
+        if want.get('tlv_select'):
+            # Create list of TLVs to be suppressed which aren't already
+            want_suppress = [key.upper() for key, value in want["tlv_select"].items() if have["tlv_select"][key] != value and value is False]
+            if want_suppress:
+                # Add previously suppressed TLVs to the list as we are doing a PUT op
+                want_suppress.extend([key.upper() for key, value in have["tlv_select"].items() if value is False])
+                request["data"]["openconfig-lldp:config"].update(
+                    {"suppress-tlv-advertisement": want_suppress})
+                request["data"]["openconfig-lldp:config"]["suppress-tlv-advertisement"].sort()

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

@@ -0,0 +1,243 @@
+#
+# -*- 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 class
+It is in this file where the current configuration (as dict)
+is compared to the provided configuration (as dict) and the command set
+necessary to bring the current configuration to it's desired end-state is
+created
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import json
+from copy import deepcopy
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base import ConfigBase
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list, dict_diff
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.facts import Facts
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+
+
+class Lldp_interfaces(ConfigBase):
+    """
+    The exos_lldp_interfaces class
+    """
+
+    gather_subset = [
+        '!all',
+        '!min',
+    ]
+
+    gather_network_resources = [
+        'lldp_interfaces',
+    ]
+
+    LLDP_INTERFACE = {
+        "data": {
+            "openconfig-lldp:config": {
+                "name": None,
+                "enabled": True
+            }
+        },
+        "method": "PATCH",
+        "path": None
+    }
+
+    LLDP_PATH = "/rest/restconf/data/openconfig-lldp:lldp/interfaces/interface="
+
+    def __init__(self, module):
+        super(Lldp_interfaces, self).__init__(module)
+
+    def get_lldp_interfaces_facts(self):
+        """ Get the 'facts' (the current configuration)
+
+        :rtype: A dictionary
+        :returns: The current configuration as a dictionary
+        """
+        facts, _warnings = Facts(self._module).get_facts(
+            self.gather_subset, self.gather_network_resources)
+        lldp_interfaces_facts = facts['ansible_network_resources'].get(
+            'lldp_interfaces')
+        if not lldp_interfaces_facts:
+            return []
+        return lldp_interfaces_facts
+
+    def execute_module(self):
+        """ Execute the module
+
+        :rtype: A dictionary
+        :returns: The result from module execution
+        """
+        result = {'changed': False}
+        warnings = list()
+        requests = list()
+
+        existing_lldp_interfaces_facts = self.get_lldp_interfaces_facts()
+        requests.extend(self.set_config(existing_lldp_interfaces_facts))
+        if requests:
+            if not self._module.check_mode:
+                send_requests(self._module, requests=requests)
+            result['changed'] = True
+        result['requests'] = requests
+
+        changed_lldp_interfaces_facts = self.get_lldp_interfaces_facts()
+
+        result['before'] = existing_lldp_interfaces_facts
+        if result['changed']:
+            result['after'] = changed_lldp_interfaces_facts
+
+        result['warnings'] = warnings
+        return result
+
+    def set_config(self, existing_lldp_interfaces_facts):
+        """ Collect the configuration from the args passed to the module,
+            collect the current configuration (as a dict from facts)
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        want = self._module.params['config']
+        have = existing_lldp_interfaces_facts
+        resp = self.set_state(want, have)
+        return to_list(resp)
+
+    def set_state(self, want, have):
+        """ Select the appropriate function based on the state provided
+
+        :param want: the desired configuration as a dictionary
+        :param have: the current configuration as a dictionary
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        state = self._module.params['state']
+        if state == 'overridden':
+            requests = self._state_overridden(want, have)
+        elif state == 'deleted':
+            requests = self._state_deleted(want, have)
+        elif state == 'merged':
+            requests = self._state_merged(want, have)
+        elif state == 'replaced':
+            requests = self._state_replaced(want, have)
+        return requests
+
+    def _state_replaced(self, want, have):
+        """ The request generator when state is replaced
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+
+        for w in want:
+            for h in have:
+                if w['name'] == h['name']:
+                    lldp_request = self._update_patch_request(w, h)
+                    if lldp_request["path"]:
+                        lldp_request["data"] = json.dumps(lldp_request["data"])
+                        requests.append(lldp_request)
+
+        return requests
+
+    def _state_overridden(self, want, have):
+        """ The request generator when state is overridden
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        have_copy = []
+        for w in want:
+            for h in have:
+                if w['name'] == h['name']:
+                    lldp_request = self._update_patch_request(w, h)
+                    if lldp_request["path"]:
+                        lldp_request["data"] = json.dumps(lldp_request["data"])
+                        requests.append(lldp_request)
+                    have_copy.append(h)
+
+        for h in have:
+            if h not in have_copy:
+                if not h['enabled']:
+                    lldp_delete = self._update_delete_request(h)
+                    if lldp_delete["path"]:
+                        lldp_delete["data"] = json.dumps(lldp_delete["data"])
+                        requests.append(lldp_delete)
+
+        return requests
+
+    def _state_merged(self, want, have):
+        """ The request generator when state is merged
+
+        :rtype: A list
+        :returns: the requests necessary to merge the provided into
+                  the current configuration
+        """
+        requests = []
+        for w in want:
+            for h in have:
+                if w['name'] == h['name']:
+                    lldp_request = self._update_patch_request(w, h)
+                    if lldp_request["path"]:
+                        lldp_request["data"] = json.dumps(lldp_request["data"])
+                        requests.append(lldp_request)
+
+        return requests
+
+    def _state_deleted(self, want, have):
+        """ The request generator when state is deleted
+
+        :rtype: A list
+        :returns: the requests necessary to remove the current configuration
+                  of the provided objects
+        """
+        requests = []
+        if want:
+            for w in want:
+                for h in have:
+                    if w['name'] == h['name']:
+                        if not h['enabled']:
+                            lldp_delete = self._update_delete_request(h)
+                            if lldp_delete["path"]:
+                                lldp_delete["data"] = json.dumps(
+                                    lldp_delete["data"])
+                                requests.append(lldp_delete)
+        else:
+            for h in have:
+                if not h['enabled']:
+                    lldp_delete = self._update_delete_request(h)
+                    if lldp_delete["path"]:
+                        lldp_delete["data"] = json.dumps(lldp_delete["data"])
+                        requests.append(lldp_delete)
+
+        return requests
+
+    def _update_patch_request(self, want, have):
+
+        lldp_request = deepcopy(self.LLDP_INTERFACE)
+
+        if have['enabled'] != want['enabled']:
+            lldp_request["data"]["openconfig-lldp:config"]["name"] = want[
+                'name']
+            lldp_request["data"]["openconfig-lldp:config"]["enabled"] = want[
+                'enabled']
+            lldp_request["path"] = self.LLDP_PATH + str(
+                want['name']) + "/config"
+
+        return lldp_request
+
+    def _update_delete_request(self, have):
+
+        lldp_delete = deepcopy(self.LLDP_INTERFACE)
+
+        lldp_delete["data"]["openconfig-lldp:config"]["name"] = have['name']
+        lldp_delete["data"]["openconfig-lldp:config"]["enabled"] = True
+        lldp_delete["path"] = self.LLDP_PATH + str(have['name']) + "/config"
+
+        return lldp_delete

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

@@ -0,0 +1,277 @@
+#
+# -*- 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 class
+It is in this file where the current configuration (as dict)
+is compared to the provided configuration (as dict) and the command set
+necessary to bring the current configuration to it's desired end-state is
+created
+"""
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import json
+from copy import deepcopy
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base import ConfigBase
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list, dict_diff
+from ansible_collections.community.general.plugins.module_utils.network.exos.facts.facts import Facts
+from ansible_collections.community.general.plugins.module_utils.network.exos.exos import send_requests
+from ansible_collections.community.general.plugins.module_utils.network.exos.utils.utils import search_obj_in_list
+
+
+class Vlans(ConfigBase):
+    """
+    The exos_vlans class
+    """
+
+    gather_subset = [
+        '!all',
+        '!min',
+    ]
+
+    gather_network_resources = [
+        'vlans',
+    ]
+
+    VLAN_POST = {
+        "data": {"openconfig-vlan:vlans": []},
+        "method": "POST",
+        "path": "/rest/restconf/data/openconfig-vlan:vlans/"
+    }
+
+    VLAN_PATCH = {
+        "data": {"openconfig-vlan:vlans": {"vlan": []}},
+        "method": "PATCH",
+        "path": "/rest/restconf/data/openconfig-vlan:vlans/"
+    }
+
+    VLAN_DELETE = {
+        "method": "DELETE",
+        "path": None
+    }
+
+    DEL_PATH = "/rest/restconf/data/openconfig-vlan:vlans/vlan="
+
+    REQUEST_BODY = {
+        "config": {"name": None, "status": "ACTIVE", "tpid": "oc-vlan-types:TPID_0x8100", "vlan-id": None}
+    }
+
+    def __init__(self, module):
+        super(Vlans, self).__init__(module)
+
+    def get_vlans_facts(self):
+        """ Get the 'facts' (the current configuration)
+
+        :rtype: A dictionary
+        :returns: The current configuration as a dictionary
+        """
+        facts, _warnings = Facts(self._module).get_facts(
+            self.gather_subset, self.gather_network_resources)
+        vlans_facts = facts['ansible_network_resources'].get('vlans')
+        if not vlans_facts:
+            return []
+        return vlans_facts
+
+    def execute_module(self):
+        """ Execute the module
+
+        :rtype: A dictionary
+        :returns: The result from module execution
+        """
+        result = {'changed': False}
+        warnings = list()
+        requests = list()
+
+        existing_vlans_facts = self.get_vlans_facts()
+        requests.extend(self.set_config(existing_vlans_facts))
+        if requests:
+            if not self._module.check_mode:
+                send_requests(self._module, requests=requests)
+            result['changed'] = True
+        result['requests'] = requests
+
+        changed_vlans_facts = self.get_vlans_facts()
+
+        result['before'] = existing_vlans_facts
+        if result['changed']:
+            result['after'] = changed_vlans_facts
+
+        result['warnings'] = warnings
+        return result
+
+    def set_config(self, existing_vlans_facts):
+        """ Collect the configuration from the args passed to the module,
+            collect the current configuration (as a dict from facts)
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        want = self._module.params['config']
+        have = existing_vlans_facts
+        resp = self.set_state(want, have)
+        return to_list(resp)
+
+    def set_state(self, want, have):
+        """ Select the appropriate function based on the state provided
+
+        :param want: the desired configuration as a dictionary
+        :param have: the current configuration as a dictionary
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        state = self._module.params['state']
+        if state == 'overridden':
+            requests = self._state_overridden(want, have)
+        elif state == 'deleted':
+            requests = self._state_deleted(want, have)
+        elif state == 'merged':
+            requests = self._state_merged(want, have)
+        elif state == 'replaced':
+            requests = self._state_replaced(want, have)
+        return requests
+
+    def _state_replaced(self, want, have):
+        """ The request generator when state is replaced
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        request_patch = deepcopy(self.VLAN_PATCH)
+
+        for w in want:
+            if w.get('vlan_id'):
+                h = search_obj_in_list(w['vlan_id'], have, 'vlan_id')
+                if h:
+                    if dict_diff(w, h):
+                        request_body = self._update_patch_request(w)
+                        request_patch["data"]["openconfig-vlan:vlans"]["vlan"].append(request_body)
+                else:
+                    request_post = self._update_post_request(w)
+                    requests.append(request_post)
+
+        if len(request_patch["data"]["openconfig-vlan:vlans"]["vlan"]):
+            request_patch["data"] = json.dumps(request_patch["data"])
+            requests.append(request_patch)
+
+        return requests
+
+    def _state_overridden(self, want, have):
+        """ The request generator when state is overridden
+
+        :rtype: A list
+        :returns: the requests necessary to migrate the current configuration
+                  to the desired configuration
+        """
+        requests = []
+        request_patch = deepcopy(self.VLAN_PATCH)
+
+        have_copy = []
+        for w in want:
+            if w.get('vlan_id'):
+                h = search_obj_in_list(w['vlan_id'], have, 'vlan_id')
+                if h:
+                    if dict_diff(w, h):
+                        request_body = self._update_patch_request(w)
+                        request_patch["data"]["openconfig-vlan:vlans"]["vlan"].append(request_body)
+                    have_copy.append(h)
+                else:
+                    request_post = self._update_post_request(w)
+                    requests.append(request_post)
+
+        for h in have:
+            if h not in have_copy and h['vlan_id'] != 1:
+                request_delete = self._update_delete_request(h)
+                requests.append(request_delete)
+
+        if len(request_patch["data"]["openconfig-vlan:vlans"]["vlan"]):
+            request_patch["data"] = json.dumps(request_patch["data"])
+            requests.append(request_patch)
+
+        return requests
+
+    def _state_merged(self, want, have):
+        """ The requests generator when state is merged
+
+        :rtype: A list
+        :returns: the requests necessary to merge the provided into
+                  the current configuration
+        """
+        requests = []
+
+        request_patch = deepcopy(self.VLAN_PATCH)
+
+        for w in want:
+            if w.get('vlan_id'):
+                h = search_obj_in_list(w['vlan_id'], have, 'vlan_id')
+                if h:
+                    if dict_diff(w, h):
+                        request_body = self._update_patch_request(w)
+                        request_patch["data"]["openconfig-vlan:vlans"]["vlan"].append(request_body)
+                else:
+                    request_post = self._update_post_request(w)
+                    requests.append(request_post)
+
+        if len(request_patch["data"]["openconfig-vlan:vlans"]["vlan"]):
+            request_patch["data"] = json.dumps(request_patch["data"])
+            requests.append(request_patch)
+        return requests
+
+    def _state_deleted(self, want, have):
+        """ The requests generator when state is deleted
+
+        :rtype: A list
+        :returns: the requests necessary to remove the current configuration
+                  of the provided objects
+        """
+        requests = []
+
+        if want:
+            for w in want:
+                if w.get('vlan_id'):
+                    h = search_obj_in_list(w['vlan_id'], have, 'vlan_id')
+                    if h:
+                        request_delete = self._update_delete_request(h)
+                        requests.append(request_delete)
+
+        else:
+            if not have:
+                return requests
+            for h in have:
+                if h['vlan_id'] == 1:
+                    continue
+                else:
+                    request_delete = self._update_delete_request(h)
+                    requests.append(request_delete)
+
+        return requests
+
+    def _update_vlan_config_body(self, want, request):
+        request["config"]["name"] = want["name"]
+        request["config"]["status"] = "SUSPENDED" if want["state"] == "suspend" else want["state"].upper()
+        request["config"]["vlan-id"] = want["vlan_id"]
+        return request
+
+    def _update_patch_request(self, want):
+        request_body = deepcopy(self.REQUEST_BODY)
+        request_body = self._update_vlan_config_body(want, request_body)
+        return request_body
+
+    def _update_post_request(self, want):
+        request_post = deepcopy(self.VLAN_POST)
+        request_body = deepcopy(self.REQUEST_BODY)
+        request_body = self._update_vlan_config_body(want, request_body)
+        request_post["data"]["openconfig-vlan:vlans"].append(request_body)
+        request_post["data"] = json.dumps(request_post["data"])
+        return request_post
+
+    def _update_delete_request(self, have):
+        request_delete = deepcopy(self.VLAN_DELETE)
+        request_delete["path"] = self.DEL_PATH + str(have['vlan_id'])
+        return request_delete