diff --git a/plugins/module_utils/network/vyos/config/l3_interfaces/l3_interfaces.py b/plugins/module_utils/network/vyos/config/l3_interfaces/l3_interfaces.py index 2506abb5..f7b76af9 100644 --- a/plugins/module_utils/network/vyos/config/l3_interfaces/l3_interfaces.py +++ b/plugins/module_utils/network/vyos/config/l3_interfaces/l3_interfaces.py @@ -1,367 +1,377 @@ # # -*- 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 vyos_l3_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 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 ( remove_empties, to_list, ) from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import Facts from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import ( diff_list_of_dicts, get_interface_type, search_obj_in_list, ) class L3_interfaces(ConfigBase): """ The vyos_l3_interfaces class """ gather_subset = [ "!all", "!min", ] gather_network_resources = [ "l3_interfaces", ] def __init__(self, module): super(L3_interfaces, self).__init__(module) def get_l3_interfaces_facts(self, data=None): """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, data=data, ) l3_interfaces_facts = facts["ansible_network_resources"].get("l3_interfaces") if not l3_interfaces_facts: return [] return l3_interfaces_facts def execute_module(self): """Execute the module :rtype: A dictionary :returns: The result from module execution """ result = {"changed": False} warnings = list() commands = list() if self.state in self.ACTION_STATES: existing_l3_interfaces_facts = self.mutate_autoconfig(self.get_l3_interfaces_facts()) else: existing_l3_interfaces_facts = [] if self.state in self.ACTION_STATES or self.state == "rendered": commands.extend(self.set_config(existing_l3_interfaces_facts)) if commands and self.state in self.ACTION_STATES: if not self._module.check_mode: self._connection.edit_config(commands) result["changed"] = True if self.state in self.ACTION_STATES: result["commands"] = commands if self.state in self.ACTION_STATES or self.state == "gathered": changed_l3_interfaces_facts = self.mutate_autoconfig(self.get_l3_interfaces_facts()) elif self.state == "rendered": result["rendered"] = commands elif self.state == "parsed": running_config = self._module.params["running_config"] if not running_config: self._module.fail_json( msg="value of running_config parameter must not be empty for state parsed", ) result["parsed"] = self.mutate_autoconfig( self.get_l3_interfaces_facts(data=running_config), ) else: changed_l3_interfaces_facts = [] if self.state in self.ACTION_STATES: result["before"] = existing_l3_interfaces_facts if result["changed"]: result["after"] = changed_l3_interfaces_facts elif self.state == "gathered": result["gathered"] = changed_l3_interfaces_facts result["warnings"] = warnings return result def set_config(self, existing_l3_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 commands necessary to migrate the current configuration to the desired configuration """ want = self._module.params["config"] have = existing_l3_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 commands necessary to migrate the current configuration to the desired configuration """ commands = [] state = self._module.params["state"] if state in ("merged", "replaced", "overridden", "rendered") and not want: self._module.fail_json( msg="value of config parameter must not be empty for state {0}".format(state), ) if state == "overridden": commands.extend(self._state_overridden(want=want, have=have)) elif state == "deleted": if not want: for intf in have: commands.extend(self._state_deleted({"name": intf["name"]}, intf)) else: for item in want: obj_in_have = search_obj_in_list(item["name"], have) commands.extend(self._state_deleted(item, obj_in_have)) else: for item in want: name = item["name"] obj_in_have = search_obj_in_list(name, have) if not obj_in_have: obj_in_have = {"name": item["name"]} if state in ("merged", "rendered"): commands.extend(self._state_merged(item, obj_in_have)) elif state == "replaced": commands.extend(self._state_replaced(item, obj_in_have)) commands = [command.replace("auto-config", "autoconf") for command in commands] return commands def _state_replaced(self, want, have): """The command generator when state is replaced :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ commands = [] if have: commands.extend(self._state_deleted(want, have)) commands.extend(self._state_merged(want, have)) return commands def _state_overridden(self, want, have): """The command generator when state is overridden :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ commands = [] for intf in have: intf_in_want = search_obj_in_list(intf["name"], want) if not intf_in_want: commands.extend(self._state_deleted({"name": intf["name"]}, intf)) for intf in want: intf_in_have = search_obj_in_list(intf["name"], have) commands.extend(self._state_replaced(intf, intf_in_have)) return commands def _state_merged(self, want, have): """The command generator when state is merged :rtype: A list :returns: the commands necessary to merge the provided into the current configuration """ commands = [] want_copy = deepcopy(remove_empties(want)) have_copy = deepcopy(remove_empties(have)) want_vifs = want_copy.pop("vifs", []) have_vifs = have_copy.pop("vifs", []) for update in self._get_updates(want_copy, have_copy): for key, value in update.items(): commands.append( self._compute_commands(key=key, value=value, interface=want_copy["name"]), ) if want_vifs: for want_vif in want_vifs: have_vif = search_obj_in_list(want_vif["vlan_id"], have_vifs, key="vlan_id") if not have_vif: have_vif = {} for update in self._get_updates(want_vif, have_vif): for key, value in update.items(): commands.append( self._compute_commands( key=key, value=value, interface=want_copy["name"], vif=want_vif["vlan_id"], ), ) return commands def _state_deleted(self, want, have): + """The command generator when state is deleted + + Deletes only the L3 address attributes (base interface and VIFs) + owned by this module, never the interface subtree, so L2 settings + are preserved. + + :rtype: A list + :returns: the commands necessary to remove the current configuration + of the provided objects + """ commands = [] want_copy = deepcopy(remove_empties(want)) have_copy = deepcopy(have) if have_copy is not None: if all(v in (None, {}, []) for k, v in want_copy.items() if k != "name"): # Only delete L3 attributes we own — do not touch L2 config have_vifs = have_copy.pop("vifs", []) or [] for addr_family in ("ipv4", "ipv6"): for addr in have_copy.get(addr_family) or []: commands.append( self._compute_commands( key="address", value=addr["address"], interface=want_copy["name"], remove=True, ), ) for have_vif in have_vifs: for addr_family in ("ipv4", "ipv6"): for addr in have_vif.get(addr_family) or []: commands.append( self._compute_commands( key="address", value=addr["address"], interface=want_copy["name"], vif=have_vif["vlan_id"], remove=True, ), ) return commands want_vifs = want_copy.pop("vifs", []) have_vifs = have_copy.pop("vifs", []) if have_vifs: for have_vif in have_vifs: want_vif = search_obj_in_list(have_vif["vlan_id"], want_vifs, key="vlan_id") if not want_vif: want_vif = {"vlan_id": have_vif["vlan_id"]} for update in self._get_updates(have_vif, want_vif): for key, value in update.items(): commands.append( self._compute_commands( key=key, interface=want_copy["name"], value=value, vif=want_vif["vlan_id"], remove=True, ), ) for update in self._get_updates(have_copy, want_copy): for key, value in update.items(): commands.append( self._compute_commands( key=key, value=value, interface=want_copy["name"], remove=True, ), ) return commands def _compute_commands(self, interface, key, vif=None, value=None, remove=False): if value == "auto-config" and vif is None: intf_context = "interfaces {0} {1} ipv6".format( get_interface_type(interface), interface, ) else: intf_context = "interfaces {0} {1}".format(get_interface_type(interface), interface) set_cmd = "set {0}".format(intf_context) del_cmd = "delete {0}".format(intf_context) if vif: suffix = " ipv6" if value == "auto-config" else "" set_cmd += f" vif {vif}{suffix}" del_cmd += f" vif {vif}{suffix}" if remove and key and value: command = "{0} {1} '{2}'".format(del_cmd, key, value) elif remove and not (key and value): command = "{0}".format(del_cmd) else: command = "{0} {1} '{2}'".format(set_cmd, key, value) return command def _get_updates(self, want, have): updates = [] updates = diff_list_of_dicts(want.get("ipv4", []), have.get("ipv4", [])) updates.extend(diff_list_of_dicts(want.get("ipv6", []), have.get("ipv6", []))) return updates def mutate_autoconfig(self, obj): if isinstance(obj, dict): return dict(map(lambda kv: (kv[0], self.mutate_autoconfig(kv[1])), obj.items())) if isinstance(obj, list): return list(map(self.mutate_autoconfig, obj)) if isinstance(obj, str): return obj.replace("autoconf", "auto-config") return obj diff --git a/tests/unit/modules/network/vyos/fixtures/vyos_l3_interfaces_config.cfg b/tests/unit/modules/network/vyos/fixtures/vyos_l3_interfaces_config.cfg index 011b0ee7..8f9609cd 100644 --- a/tests/unit/modules/network/vyos/fixtures/vyos_l3_interfaces_config.cfg +++ b/tests/unit/modules/network/vyos/fixtures/vyos_l3_interfaces_config.cfg @@ -1,8 +1,8 @@ set interfaces ethernet eth0 address 'dhcp' set interfaces ethernet eth1 address '192.0.2.14/24' set interfaces ethernet eth2 address '192.0.2.10/24' set interfaces ethernet eth2 address '2001:db8::10/32' set interfaces ethernet eth3 address '198.51.100.10/24' set interfaces ethernet eth3 vif 101 address '198.51.100.130/25' set interfaces ethernet eth3 vif 102 address '2001:db8:4000::3/34' -set interfaces loopback lo +set interfaces loopback 'lo' diff --git a/tests/unit/modules/network/vyos/test_vyos_l3_interfaces.py b/tests/unit/modules/network/vyos/test_vyos_l3_interfaces.py index 3db6296a..7932f63d 100644 --- a/tests/unit/modules/network/vyos/test_vyos_l3_interfaces.py +++ b/tests/unit/modules/network/vyos/test_vyos_l3_interfaces.py @@ -1,278 +1,278 @@ # (c) 2024 VyOS Networks # # This file is part of Ansible # # Ansible is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Ansible 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. # # You should have received a copy of the GNU General Public License # along with Ansible. If not, see . from __future__ import absolute_import, division, print_function __metaclass__ = type from unittest.mock import patch from ansible_collections.vyos.vyos.plugins.modules import vyos_l3_interfaces from ansible_collections.vyos.vyos.tests.unit.modules.utils import set_module_args from .vyos_module import TestVyosModule, load_fixture class TestVyosL3InterfacesModule(TestVyosModule): module = vyos_l3_interfaces def setUp(self): super(TestVyosL3InterfacesModule, self).setUp() self.mock_get_config = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.network.Config.get_config", ) self.get_config = self.mock_get_config.start() self.mock_load_config = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.network.Config.load_config", ) self.load_config = self.mock_load_config.start() self.mock_get_resource_connection_config = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base.get_resource_connection", ) self.get_resource_connection_config = self.mock_get_resource_connection_config.start() self.mock_get_resource_connection_facts = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.facts.facts.get_resource_connection", ) self.get_resource_connection_facts = self.mock_get_resource_connection_facts.start() def tearDown(self): super(TestVyosL3InterfacesModule, self).tearDown() self.mock_get_resource_connection_config.stop() self.mock_get_resource_connection_facts.stop() self.mock_get_config.stop() self.mock_load_config.stop() def load_fixtures(self, commands=None, filename=None): fixture_data = load_fixture("vyos_l3_interfaces_config.cfg") self.get_resource_connection_facts.return_value.get_config.return_value = fixture_data def test_vyos_l3_interfaces_merged(self): """Merge a new IPv4 address onto eth1 (currently has 192.0.2.14/24).""" set_module_args( dict( config=[ dict( name="eth1", ipv4=[dict(address="192.0.2.1/24")], ), ], state="merged", ), ) commands = [ "set interfaces ethernet eth1 address '192.0.2.1/24'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_merged_idempotent(self): """No change when desired config already matches existing config.""" set_module_args( dict( config=[ dict( name="eth1", ipv4=[dict(address="192.0.2.14/24")], ), ], state="merged", ), ) self.execute_module(changed=False, commands=[]) def test_vyos_l3_interfaces_merged_ipv6(self): """Merge a new IPv6 address onto eth1.""" set_module_args( dict( config=[ dict( name="eth1", ipv6=[dict(address="2001:db8::1/32")], ), ], state="merged", ), ) commands = [ "set interfaces ethernet eth1 address '2001:db8::1/32'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_replaced(self): """Replace eth1 addresses: remove existing, add new.""" set_module_args( dict( config=[ dict( name="eth1", ipv4=[dict(address="10.0.0.1/24")], ), ], state="replaced", ), ) commands = [ "delete interfaces ethernet eth1 address '192.0.2.14/24'", "set interfaces ethernet eth1 address '10.0.0.1/24'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_overridden(self): - """Override: keep only eth2, delete all other interface stanzas included in the L3 facts.""" + """Override: keep only eth2; delete L3 addresses from all other interfaces.""" set_module_args( dict( config=[ dict( name="eth2", ipv4=[dict(address="192.0.2.10/24")], ipv6=[dict(address="2001:db8::10/32")], ), ], state="overridden", ), ) commands = [ "delete interfaces ethernet eth0 address 'dhcp'", "delete interfaces ethernet eth1 address '192.0.2.14/24'", "delete interfaces ethernet eth3 address '198.51.100.10/24'", "delete interfaces ethernet eth3 vif 101 address '198.51.100.130/25'", "delete interfaces ethernet eth3 vif 102 address '2001:db8:4000::3/34'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_deleted(self): """Delete all L3 config from eth1.""" set_module_args( dict( config=[ dict(name="eth1"), ], state="deleted", ), ) commands = [ "delete interfaces ethernet eth1 address '192.0.2.14/24'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_rendered(self): """Render set commands without connecting to the device.""" set_module_args( dict( config=[ dict( name="eth0", ipv4=[dict(address="dhcp")], ), dict( name="eth1", ipv4=[dict(address="192.0.2.14/24")], ), ], state="rendered", ), ) rendered_cmds = [ "set interfaces ethernet eth0 address 'dhcp'", "set interfaces ethernet eth1 address '192.0.2.14/24'", ] result = self.execute_module(changed=False) self.assertEqual( sorted(result["rendered"]), sorted(rendered_cmds), result["rendered"], ) def test_vyos_l3_interfaces_gathered(self): """Gather L3 interface facts from the device.""" set_module_args(dict(state="gathered")) result = self.execute_module(changed=False) gathered = result["gathered"] # Verify eth1 is present with its IPv4 address eth1 = next((i for i in gathered if i["name"] == "eth1"), None) self.assertIsNotNone(eth1) self.assertIn({"address": "192.0.2.14/24"}, eth1["ipv4"]) def test_vyos_l3_interfaces_parsed(self): """Parse a raw config string into structured data.""" raw_config = ( "set interfaces ethernet eth0 address 'dhcp'\n" "set interfaces ethernet eth1 address '192.0.2.14/24'\n" ) set_module_args( dict( running_config=raw_config, state="parsed", ), ) result = self.execute_module(changed=False) parsed = result["parsed"] eth0 = next((i for i in parsed if i["name"] == "eth0"), None) self.assertIsNotNone(eth0) self.assertIn({"address": "dhcp"}, eth0["ipv4"]) eth1 = next((i for i in parsed if i["name"] == "eth1"), None) self.assertIsNotNone(eth1) self.assertIn({"address": "192.0.2.14/24"}, eth1["ipv4"]) def test_vyos_l3_interfaces_vif_merged(self): """Merge a new address onto a VIF sub-interface.""" set_module_args( dict( config=[ dict( name="eth3", vifs=[ dict( vlan_id=101, ipv4=[dict(address="198.51.100.200/25")], ), ], ), ], state="merged", ), ) commands = [ "set interfaces ethernet eth3 vif 101 address '198.51.100.200/25'", ] self.execute_module(changed=True, commands=commands) def test_vyos_l3_interfaces_vif_deleted(self): """Delete all L3 addresses from eth3, including VIF sub-interfaces.""" set_module_args( dict( config=[ dict( name="eth3", vifs=[ dict(vlan_id=101), dict(vlan_id=102), ], ), ], state="deleted", ), ) commands = [ "delete interfaces ethernet eth3 vif 101 address '198.51.100.130/25'", "delete interfaces ethernet eth3 vif 102 address '2001:db8:4000::3/34'", "delete interfaces ethernet eth3 address '198.51.100.10/24'", ] self.execute_module(changed=True, commands=commands)