[networking_mapper] Complete the Move to best effort approach and all…

…ow multiple base nets

plugins/action/ci_net_map.py

@@ -34,16 +34,9 @@
     - Dict that contains the list of MAC addresses of each instance to be mapped.
     - Each dict entry is a list of dicts with at least a `mac` field.
     - Each item in the list is an interface in a given infrastructure network.
-    - If not passed a partial map is done.
+    - It's required for full maps.
     type: iterable
     required: false
-  network_name:
-    description:
-    - Required if interfaces_info is given.
-    - Represents the name of the physical network that accommodates the OSP networks.
-    - Filters out the interfaces_info interfaces by selecting only the proper one.
-    type: str
-    required: false
   search_domain_base:
     description:
     - Domain name used for generating networks search domains.
@@ -247,8 +240,8 @@
     type: bool
 """
 
-from ansible.plugins.action import ActionBase
 from ansible.errors import AnsibleActionFail
+from ansible.plugins.action import ActionBase
 
 from ansible_collections.cifmw.general.plugins.module_utils.encoding import (
     ansible_encoding,
@@ -260,26 +253,6 @@
 
 
 class ActionModule(ActionBase):
-    @staticmethod
-    def __build_interfaces_info_dict(
-        ifaces_info_raw: typing.Dict[str, typing.Any], net_name: str
-    ) -> typing.Dict[str, typing.Any]:
-        ifaces_info_dict = {}
-        for instance_name, ifaces_list in ifaces_info_raw.items():
-            iface_data = next(
-                (
-                    iface_content
-                    for iface_content in ifaces_list
-                    if "network" in iface_content
-                    and iface_content["network"] == net_name
-                ),
-                None,
-            )
-            if instance_name not in ifaces_info_dict and iface_data:
-                ifaces_info_dict[instance_name] = iface_data
-
-        return ifaces_info_dict
-
     def run(self, tmp=None, task_vars=None):
         if task_vars is None:
             task_vars = dict()
@@ -292,33 +265,18 @@ def run(self, tmp=None, task_vars=None):
         if not networking_definition:
             raise AnsibleActionFail("networking_definition is a mandatory argument")
 
-        interfaces_info_dict = None
-        is_complete_map = "interfaces_info" in task_args
-        network_name = task_args.get("network_name", None)
-        if is_complete_map and not network_name:
-            raise AnsibleActionFail(
-                "network_name is a mandatory " "argument if interfaces_info is given"
-            )
-        elif is_complete_map:
-            interfaces_info_dict = self.__build_interfaces_info_dict(
-                task_args["interfaces_info"], network_name
-            )
-
         mapper = networking_mapper.NetworkingDefinitionMapper(
             dict(task_vars["hostvars"]),
             task_vars["groups"],
             options=networking_mapper.NetworkingMapperOptions.from_dict(task_args),
         )
 
         try:
-            mapping_result = (
-                mapper.map_complete(networking_definition, interfaces_info_dict)
-                if is_complete_map
-                else mapper.map_partial(networking_definition)
+            mapping_result = mapper.map(
+                networking_definition, interfaces_info=task_args.get("interfaces_info", None)
             )
             result["failed"] = False
             result["networking_env_definition"] = mapping_result
-            result["complete_map"] = is_complete_map
         except exceptions.NetworkMappingError as run_exception:
             result = {**result, **(run_exception.to_raw()), "failed": True}
 

plugins/module_utils/net_map/networking_definition.py

@@ -1608,19 +1608,16 @@ class GroupTemplateNetworkDefinition:
         skip_nm_configuration: Indicates if the instances of the
             group should skip configuring Network Manager for the
             given network.
-        is_trunk_parent: indicates wheater the instance nic for
-            this network is parent for trunked vlans.
-        trunk_parent: idicates which instance network is vlan
-            parent for this network.
+        trunk_parent: if the network is a trunk in the target instances,
+            it points to the GroupTemplateNetworkDefinition of that network.
     """
 
     network: NetworkDefinition
     group_name: str
     ipv6_range: HostNetworkRange = None
     ipv4_range: HostNetworkRange = None
     skip_nm_configuration: bool = None
-    is_trunk_parent: bool = None
-    trunk_parent: str = None
+    trunk_parent: GroupTemplateNetworkDefinition = None
 
     def __hash__(self) -> int:
         return hash(
@@ -1630,7 +1627,6 @@ def __hash__(self) -> int:
                 self.ipv4_range,
                 self.ipv6_range,
                 self.skip_nm_configuration,
-                self.is_trunk_parent,
                 self.trunk_parent,
             )
         )
@@ -1653,7 +1649,7 @@ class GroupTemplateDefinition:
             # 'network-template' is an optional field that can hold
             # the base configuration for each network. If given, each
             # declared network content will use the variables defined
-            # there as a base that can be overriden by each network
+            # there as a base that can be overridden by each network
             # content
             network-template:   # Optional template
 
@@ -1685,7 +1681,6 @@ class GroupTemplateDefinition:
     __FIELD_NETWORK_RANGE = "range"
     __FIELD_NETWORK_RANGE_IPV4 = "range-v4"
     __FIELD_NETWORK_RANGE_IPV6 = "range-v6"
-    __FIELD_IS_TRUNK_PARENT = "is_trunk_parent"
     __FIELD_TRUNK_PARENT = "trunk_parent"
 
     def __init__(
@@ -1710,7 +1705,6 @@ def __init__(
         if not group_name:
             raise ValueError("group_name is a mandatory argument")
         self.__group_name = group_name
-        self.__trunk_parents = set()
 
         self.__skip_nm_configuration: typing.Optional[bool] = None
         self.__groups_networks_definitions = {}
@@ -1764,32 +1758,39 @@ def __parse_raw(
                 or {}
             )
 
-            # Process trunk parents to populate self.__trunk_parents
-            for network_name, network_data in networks.items():
-                if network_data.get(self.__FIELD_IS_TRUNK_PARENT):
-                    self.__parse_raw_net(
-                        network_name,
-                        network_data,
-                        network_template_raw,
-                        network_definitions,
-                    )
+            # Firstly, process networks that won't be trunk parents
+            trunk_parents = {
+                net_name: net_data
+                for net_name, net_data in networks.items()
+                if self.__FIELD_TRUNK_PARENT not in net_data
+            }
+            for network_name, network_data in trunk_parents.items():
+                self.__parse_raw_net(
+                    network_name,
+                    network_data,
+                    network_template_raw,
+                    network_definitions,
+                )
 
-            # Process non trunk parents
-            for network_name, network_data in networks.items():
-                if not network_data.get(self.__FIELD_IS_TRUNK_PARENT):
-                    self.__parse_raw_net(
-                        network_name,
-                        network_data,
-                        network_template_raw,
-                        network_definitions,
-                    )
+            # Process networks that are part of a trunk
+            child_nets = dict(networks)
+            map(child_nets.pop, trunk_parents)
+            for network_name, network_data in child_nets.items():
+                self.__parse_raw_net(
+                    network_name,
+                    network_data,
+                    network_template_raw,
+                    network_definitions,
+                    trunk_parents=set(trunk_parents.keys()),
+                )
 
     def __parse_raw_net(
         self,
         network_name: str,
         network_data: typing.Dict[str, typing.Any],
         network_template_raw: typing.Dict[str, typing.Any],
         network_definitions: typing.Dict[str, NetworkDefinition],
+        trunk_parents: typing.Set[str] = None,
     ):
         network_definition = network_definitions.get(network_name, None)
         if not network_definition:
@@ -1810,24 +1811,21 @@ def __parse_raw_net(
             else None
         )
 
-        is_trunk_parent = _validate_parse_field_type(
-            self.__FIELD_IS_TRUNK_PARENT,
-            templated_net_data,
-            bool,
-            parent_name=self.group_name,
-            parent_type=self.__OBJECT_TYPE_NAME,
-            mandatory=False,
-        )
-        if is_trunk_parent:
-            self.__trunk_parents.add(network_name)
+        trunk_parent = None
+        if trunk_parents:
+            trunk_parent_str = _validate_parse_trunk_parent_field(
+                self.__FIELD_TRUNK_PARENT,
+                templated_net_data,
+                self.group_name,
+                self.__OBJECT_TYPE_NAME,
+                trunk_parents,
+            )
 
-        trunk_parent = _validate_parse_trunk_parent_field(
-            self.__FIELD_TRUNK_PARENT,
-            templated_net_data,
-            self.group_name,
-            self.__OBJECT_TYPE_NAME,
-            self.__trunk_parents,
-        )
+            trunk_parent = (
+                self.__groups_networks_definitions[trunk_parent_str]
+                if trunk_parent_str
+                else None
+            )
 
         self.__groups_networks_definitions[network_name] = (
             GroupTemplateNetworkDefinition(
@@ -1836,7 +1834,6 @@ def __parse_raw_net(
                 ipv4_range=ipv4_network_range,
                 ipv6_range=ipv6_network_range,
                 skip_nm_configuration=skip_nm_configuration,
-                is_trunk_parent=is_trunk_parent,
                 trunk_parent=trunk_parent,
             )
         )
@@ -1914,8 +1911,7 @@ class InstanceNetworkDefinition:
     ipv4: ipaddress.IPv4Address = None
     ipv6: ipaddress.IPv6Address = None
     skip_nm_configuration: bool = None
-    is_trunk_parent: bool = None
-    trunk_parent: str = None
+    trunk_parent: InstanceNetworkDefinition = None
 
     def __hash__(self) -> int:
         return hash(
@@ -1924,7 +1920,6 @@ def __hash__(self) -> int:
                 self.ipv4,
                 self.ipv6,
                 self.skip_nm_configuration,
-                self.is_trunk_parent,
                 self.trunk_parent,
             )
         )
@@ -1965,7 +1960,6 @@ class InstanceDefinition:
     __FIELD_NETWORKS = "networks"
     __FIELD_NETWORKS_IP = "ip"
     __FIELD_NETWORK_SKIP_NM = "skip-nm-configuration"
-    __FIELD_IS_TRUNK_PARENT = "is_trunk_parent"
     __FIELD_TRUNK_PARENT = "trunk_parent"
 
     def __init__(
@@ -1993,7 +1987,6 @@ def __init__(
         self.__name = name
         self.__skip_nm_configuration: typing.Optional[bool] = None
         self.__instances_network_definitions = {}
-        self.__trunk_parents: typing.Set = set()
         self.__parse_raw(raw_definition, network_definitions)
 
     @property
@@ -2029,29 +2022,36 @@ def __parse_raw(
                 field=self.__FIELD_NETWORKS,
             )
 
-        # Process trunk parents to populate self.__trunk_parents
-        for network_name, network_data in networks.items():
-            if network_data.get(self.__FIELD_IS_TRUNK_PARENT):
-                self.__parse_raw_net(
-                    network_name,
-                    network_data,
-                    network_definitions,
-                )
+        # Firstly, process networks that won't be trunk parents
+        trunk_parents = {
+            net_name: net_data
+            for net_name, net_data in networks.items()
+            if self.__FIELD_TRUNK_PARENT not in net_data
+        }
+        for network_name, network_data in trunk_parents.items():
+            self.__parse_raw_net(
+                network_name,
+                network_data,
+                network_definitions,
+            )
 
-        # Process non trunk parents
-        for network_name, network_data in networks.items():
-            if not network_data.get(self.__FIELD_IS_TRUNK_PARENT):
-                self.__parse_raw_net(
-                    network_name,
-                    network_data,
-                    network_definitions,
-                )
+        # Process networks that are part of a trunk
+        child_nets = dict(networks)
+        map(child_nets.pop, trunk_parents)
+        for network_name, network_data in child_nets.items():
+            self.__parse_raw_net(
+                network_name,
+                network_data,
+                network_definitions,
+                trunk_parents=set(trunk_parents.keys()),
+            )
 
     def __parse_raw_net(
         self,
         network_name: str,
         network_data: typing.Dict[str, typing.Any],
         network_definitions: typing.Dict[str, NetworkDefinition],
+        trunk_parents: typing.Set[str] = None,
     ):
         network_definition = network_definitions.get(network_name, None)
         if not network_definition:
@@ -2076,31 +2076,27 @@ def __parse_raw_net(
             else None
         )
 
-        is_trunk_parent = _validate_parse_field_type(
-            self.__FIELD_IS_TRUNK_PARENT,
-            network_data,
-            bool,
-            parent_name=self.name,
-            parent_type=self.__OBJECT_TYPE_NAME,
-            mandatory=False,
-        )
-        if is_trunk_parent:
-            self.__trunk_parents.add(network_name)
+        trunk_parent = None
+        if trunk_parents:
+            trunk_parent_str = _validate_parse_trunk_parent_field(
+                self.__FIELD_TRUNK_PARENT,
+                network_data,
+                self.name,
+                self.__OBJECT_TYPE_NAME,
+                trunk_parents,
+            )
 
-        trunk_parent = _validate_parse_trunk_parent_field(
-            self.__FIELD_TRUNK_PARENT,
-            network_data,
-            self.name,
-            self.__OBJECT_TYPE_NAME,
-            self.__trunk_parents,
-        )
+            trunk_parent = (
+                self.__instances_network_definitions[trunk_parent_str]
+                if trunk_parent_str
+                else None
+            )
 
         self.__instances_network_definitions[network_name] = InstanceNetworkDefinition(
             network_definition,
             ipv4=ipv4,
             ipv6=ipv6,
             skip_nm_configuration=skip_nm_configuration,
-            is_trunk_parent=is_trunk_parent,
             trunk_parent=trunk_parent,
         )