mirror of
https://github.com/ansible-collections/community.general.git
synced 2024-09-14 20:13:21 +02:00
264 lines
9.4 KiB
Python
264 lines
9.4 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Copyright: Ansible Project
|
|
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
__metaclass__ = type
|
|
|
|
ANSIBLE_METADATA = {'metadata_version': '1.1',
|
|
'status': ['preview'],
|
|
'supported_by': 'community'}
|
|
|
|
DOCUMENTATION = '''
|
|
---
|
|
module: onyx_vxlan
|
|
author: "Anas Badaha (@anasb)"
|
|
short_description: Configures Vxlan
|
|
description:
|
|
- This module provides declarative management of Vxlan configuration
|
|
on Mellanox ONYX network devices.
|
|
notes:
|
|
- Tested on ONYX evpn_dev.031.
|
|
- nve protocol must be enabled.
|
|
options:
|
|
nve_id:
|
|
description:
|
|
- nve interface ID.
|
|
required: true
|
|
loopback_id:
|
|
description:
|
|
- loopback interface ID.
|
|
bgp:
|
|
description:
|
|
- configure bgp on nve interface.
|
|
type: bool
|
|
default: true
|
|
mlag_tunnel_ip:
|
|
description:
|
|
- vxlan Mlag tunnel IP
|
|
vni_vlan_list:
|
|
description:
|
|
- Each item in the list has two attributes vlan_id, vni_id.
|
|
arp_suppression:
|
|
description:
|
|
- A flag telling if to configure arp suppression.
|
|
type: bool
|
|
default: false
|
|
'''
|
|
|
|
EXAMPLES = """
|
|
- name: configure Vxlan
|
|
onyx_vxlan:
|
|
nve_id: 1
|
|
loopback_id: 1
|
|
bgp: yes
|
|
mlag-tunnel-ip: 100.0.0.1
|
|
vni_vlan_list:
|
|
- vlan_id: 10
|
|
vni_id: 10010
|
|
- vlan_id: 6
|
|
vni_id: 10060
|
|
arp_suppression: yes
|
|
"""
|
|
|
|
RETURN = """
|
|
commands:
|
|
description: The list of configuration mode commands to send to the device.
|
|
returned: always
|
|
type: list
|
|
sample:
|
|
- interface nve 1
|
|
- interface nve 1 vxlan source interface loopback 1
|
|
- interface nve 1 nve controller bgp
|
|
- interface nve 1 vxlan mlag-tunnel-ip 100.0.0.1
|
|
- interface nve 1 nve vni 10010 vlan 10
|
|
- interface nve 1 nve vni 10060 vlan 6
|
|
- interface nve 1 nve neigh-suppression
|
|
- interface vlan 6
|
|
- interface vlan 10
|
|
"""
|
|
|
|
import re
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible_collections.community.general.plugins.module_utils.network.onyx.onyx import show_cmd
|
|
from ansible_collections.community.general.plugins.module_utils.network.onyx.onyx import BaseOnyxModule
|
|
|
|
|
|
class OnyxVxlanModule(BaseOnyxModule):
|
|
|
|
LOOPBACK_REGEX = re.compile(r'^loopback (\d+).*')
|
|
NVE_ID_REGEX = re.compile(r'^Interface NVE (\d+).*')
|
|
|
|
def init_module(self):
|
|
""" initialize module
|
|
"""
|
|
vni_vlan_spec = dict(vlan_id=dict(type=int),
|
|
vni_id=dict(type=int))
|
|
element_spec = dict(
|
|
nve_id=dict(type=int),
|
|
loopback_id=dict(type=int),
|
|
bgp=dict(default=True, type='bool'),
|
|
mlag_tunnel_ip=dict(type='str'),
|
|
vni_vlan_list=dict(type='list',
|
|
elements='dict',
|
|
options=vni_vlan_spec),
|
|
arp_suppression=dict(default=False, type='bool')
|
|
)
|
|
argument_spec = dict()
|
|
argument_spec.update(element_spec)
|
|
self._module = AnsibleModule(
|
|
argument_spec=argument_spec,
|
|
supports_check_mode=True)
|
|
|
|
def get_required_config(self):
|
|
module_params = self._module.params
|
|
self._required_config = dict(module_params)
|
|
self.validate_param_values(self._required_config)
|
|
|
|
def _set_vxlan_config(self, vxlan_config):
|
|
vxlan_config = vxlan_config[0]
|
|
if not vxlan_config:
|
|
return
|
|
nve_header = vxlan_config.get("header")
|
|
match = self.NVE_ID_REGEX.match(nve_header)
|
|
if match:
|
|
current_nve_id = int(match.group(1))
|
|
self._current_config['nve_id'] = current_nve_id
|
|
if int(current_nve_id) != self._required_config.get("nve_id"):
|
|
return
|
|
|
|
self._current_config['mlag_tunnel_ip'] = vxlan_config.get("Mlag tunnel IP")
|
|
controller_mode = vxlan_config.get("Controller mode")
|
|
if controller_mode == "BGP":
|
|
self._current_config['bgp'] = True
|
|
else:
|
|
self._current_config['bgp'] = False
|
|
|
|
loopback_str = vxlan_config.get("Source interface")
|
|
match = self.LOOPBACK_REGEX.match(loopback_str)
|
|
if match:
|
|
loopback_id = match.group(1)
|
|
self._current_config['loopback_id'] = int(loopback_id)
|
|
|
|
self._current_config['global_neigh_suppression'] = vxlan_config.get("Global Neigh-Suppression")
|
|
|
|
vni_vlan_mapping = self._current_config['vni_vlan_mapping'] = dict()
|
|
nve_detail = self._show_nve_detail()
|
|
|
|
if nve_detail is not None:
|
|
nve_detail = nve_detail[0]
|
|
|
|
if nve_detail:
|
|
for vlan_id in nve_detail:
|
|
vni_vlan_mapping[int(vlan_id)] = dict(
|
|
vni_id=int(nve_detail[vlan_id][0].get("VNI")),
|
|
arp_suppression=nve_detail[vlan_id][0].get("Neigh Suppression"))
|
|
|
|
def _show_vxlan_config(self):
|
|
cmd = "show interfaces nve"
|
|
return show_cmd(self._module, cmd, json_fmt=True, fail_on_error=False)
|
|
|
|
def _show_nve_detail(self):
|
|
cmd = "show interface nve {0} detail".format(self._required_config.get("nve_id"))
|
|
return show_cmd(self._module, cmd, json_fmt=True, fail_on_error=False)
|
|
|
|
def load_current_config(self):
|
|
self._current_config = dict()
|
|
vxlan_config = self._show_vxlan_config()
|
|
if vxlan_config:
|
|
self._set_vxlan_config(vxlan_config)
|
|
|
|
def generate_commands(self):
|
|
nve_id = self._required_config.get("nve_id")
|
|
current_nve_id = self._current_config.get("nve_id")
|
|
|
|
if current_nve_id is None:
|
|
self._add_nve_commands(nve_id)
|
|
elif current_nve_id != nve_id:
|
|
self._add_no_nve_commands(current_nve_id)
|
|
self._add_nve_commands(nve_id)
|
|
|
|
bgp = self._required_config.get("bgp")
|
|
if bgp is not None:
|
|
curr_bgp = self._current_config.get("bgp")
|
|
if bgp and bgp != curr_bgp:
|
|
self._commands.append('interface nve {0} nve controller bgp'.format(nve_id))
|
|
|
|
loopback_id = self._required_config.get("loopback_id")
|
|
if loopback_id is not None:
|
|
curr_loopback_id = self._current_config.get("loopback_id")
|
|
if loopback_id != curr_loopback_id:
|
|
self._commands.append('interface nve {0} vxlan source interface '
|
|
'loopback {1} '.format(nve_id, loopback_id))
|
|
|
|
mlag_tunnel_ip = self._required_config.get("mlag_tunnel_ip")
|
|
if mlag_tunnel_ip is not None:
|
|
curr_mlag_tunnel_ip = self._current_config.get("mlag_tunnel_ip")
|
|
if mlag_tunnel_ip != curr_mlag_tunnel_ip:
|
|
self._commands.append('interface nve {0} vxlan '
|
|
'mlag-tunnel-ip {1}'.format(nve_id, mlag_tunnel_ip))
|
|
|
|
vni_vlan_list = self._required_config.get("vni_vlan_list")
|
|
arp_suppression = self._required_config.get("arp_suppression")
|
|
if vni_vlan_list is not None:
|
|
self._generate_vni_vlan_cmds(vni_vlan_list, nve_id, arp_suppression)
|
|
|
|
def _generate_vni_vlan_cmds(self, vni_vlan_list, nve_id, arp_suppression):
|
|
|
|
current_global_arp_suppression = self._current_config.get('global_neigh_suppression')
|
|
if arp_suppression is True and current_global_arp_suppression != "Enable":
|
|
self._commands.append('interface nve {0} nve neigh-suppression'.format(nve_id))
|
|
|
|
current_vni_vlan_mapping = self._current_config.get('vni_vlan_mapping')
|
|
if current_vni_vlan_mapping is None:
|
|
for vni_vlan in vni_vlan_list:
|
|
vlan_id = vni_vlan.get("vlan_id")
|
|
vni_id = vni_vlan.get("vni_id")
|
|
self._add_vni_vlan_cmds(nve_id, vni_id, vlan_id)
|
|
self._add_arp_suppression_cmds(arp_suppression, vlan_id)
|
|
else:
|
|
for vni_vlan in vni_vlan_list:
|
|
vlan_id = vni_vlan.get("vlan_id")
|
|
vni_id = vni_vlan.get("vni_id")
|
|
|
|
currt_vlan_id = current_vni_vlan_mapping.get(vlan_id)
|
|
|
|
if currt_vlan_id is None:
|
|
self._add_vni_vlan_cmds(nve_id, vni_id, vlan_id)
|
|
self._add_arp_suppression_cmds(arp_suppression, vlan_id)
|
|
else:
|
|
current_vni_id = currt_vlan_id.get("vni_id")
|
|
current_arp_suppression = currt_vlan_id.get("arp_suppression")
|
|
|
|
if int(current_vni_id) != vni_id:
|
|
self._add_vni_vlan_cmds(nve_id, vni_id, vlan_id)
|
|
|
|
if current_arp_suppression == "Disable":
|
|
self._add_arp_suppression_cmds(arp_suppression, vlan_id)
|
|
|
|
def _add_no_nve_commands(self, current_nve_id):
|
|
self._commands.append('no interface nve {0}'.format(current_nve_id))
|
|
|
|
def _add_nve_commands(self, nve_id):
|
|
self._commands.append('interface nve {0}'.format(nve_id))
|
|
self._commands.append('exit')
|
|
|
|
def _add_vni_vlan_cmds(self, nve_id, vni_id, vlan_id):
|
|
self._commands.append('interface nve {0} nve vni {1} '
|
|
'vlan {2}'.format(nve_id, vni_id, vlan_id))
|
|
|
|
def _add_arp_suppression_cmds(self, arp_suppression, vlan_id):
|
|
if arp_suppression is True:
|
|
self._commands.append('interface vlan {0}'.format(vlan_id))
|
|
self._commands.append('exit')
|
|
|
|
|
|
def main():
|
|
""" main entry point for module execution
|
|
"""
|
|
OnyxVxlanModule.main()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|