Merge "[ovn] Handle vxlan network type"

Author: MOS CI

rockoon/cli/ovs_ovn_migration.py

@@ -611,6 +611,41 @@ def check(self):
         return routed_nets
 
 
+class TenantNetworkTypesCheck(CheckBase):
+
+    name = "Neutron tenant network types check"
+    impact = CheckImpact.MAJOR
+    error_message = (
+        "Found tenant_network_types option containing VXLAN network type. "
+        "Recommended network type for OVN is Geneve. "
+        "When migrating to OVN all existing VXLAN networks will be converted "
+        "to Geneve regardless of this setting. In case VXLAN was the default "
+        "tenant network type it will be replaced by Geneve."
+    )
+
+    def check(self):
+        LOG.info("Checking Neutron tenant_network_types")
+        osdpl = kube.get_osdpl()
+        mspec = osdpl.mspec
+        result = []
+        features_path = ["features", "neutron", "tenant_network_types"]
+        features_tnt = utils.get_in(mspec, features_path, [])
+        if "vxlan" in features_tnt:
+            result.append(":".join(features_path))
+
+        base_path = ["services", "networking", "neutron", "values", "conf"]
+        neutron_conf = utils.get_in(mspec, base_path, {})
+        tnt_paths = utils.find_key_paths(neutron_conf, "tenant_network_types")
+        for path in tnt_paths:
+            if "ml2" == path[-1]:
+                tnt_path = list(path) + ["tenant_network_types"]
+                services_tnt = utils.get_in(neutron_conf, tnt_path, "")
+                if "vxlan" in services_tnt:
+                    result.append(":".join(base_path + tnt_path))
+        LOG.info("Finished checking Neutron tenant_network_types")
+        return result
+
+
 class SubnetsNoDHCPCheck(CheckBase):
     name = "Subnets without enabled DHCP check"
     impact = CheckImpact.CRITICAL

rockoon/templates/services/networking.yaml

@@ -114,7 +114,14 @@
 {%- set cadf_audit = spec.get('features', {}).get('logging', {}).get('cadf', {'enabled': false}) %}
 {%- set cadf_audit_driver = spec.get('features', {}).get('logging', {}).get('cadf', {}).get('driver', 'messagingv2') %}
 
-{%- set neutron_tenant_network_types = spec.get('features', {}).get('neutron', {}).get('tenant_network_types', default_tenant_network_types) %}
+{%- set tenant_network_types = spec.features.neutron.get('tenant_network_types', [])  %}
+# first network type is default one, vxlan have a lot of limitations in OVN
+{%- if ovn_enabled and tenant_network_types and tenant_network_types[0] == 'vxlan' %}
+  {%- set neutron_tenant_network_types = default_tenant_network_types + tenant_network_types %}
+{%- else %}
+  {%- set neutron_tenant_network_types = tenant_network_types or default_tenant_network_types %}
+{%- endif %}
+
 {%- if 'vxlan' in neutron_tenant_network_types %}
     {%- set l3_ha_network_type = 'vxlan' %}
 {%- elif 'geneve' in neutron_tenant_network_types %}
@@ -1007,7 +1014,7 @@ spec:
               {%- if 'dns' in spec.features.services %}
                 - dns_domain_ports
               {%- endif %}
-              tenant_network_types: {{ spec.features.neutron.get('tenant_network_types', default_tenant_network_types)|join(',') }}
+              tenant_network_types: {{ neutron_tenant_network_types|join(',') }}
           {%- if baremetal_enabled %}
             ngs_coordination:
               backend_url: {{ get_etcd3_endpoint(spec.openstack_version, 'etcd3gw') }}

rockoon/utils.py

@@ -57,6 +57,34 @@ def get_in(d: Dict, keys: List, default=None):
         return default
 
 
+def find_key_paths(data, target_key, parent_path=None):
+    """
+    Recursively finds all parent key paths leading to a target key in a nested dictionary.
+    Nested lists of dictionaries are not supported.
+
+    :param data: Dictionary to search.
+    :param target_key: Key to search for.
+    :param parent_path: Internal use for recursion.
+    :return: Set of tuples, each containing the parent keys leading to the target key.
+    """
+    if parent_path is None:
+        parent_path = tuple()
+
+    found_paths = []
+
+    if isinstance(data, dict):
+        for key, value in data.items():
+            # If we find the target key
+            if key == target_key:
+                found_paths.append(parent_path)
+            # Recurse into nested dictionaries
+            if isinstance(value, dict):
+                found_paths.extend(
+                    find_key_paths(value, target_key, parent_path + (key,))
+                )
+    return set(found_paths)
+
+
 OSCTL_LOGGING_CONF_FILE = os.environ.get(
     "OSCTL_LOGGING_CONF_FILE", "/etc/rockoon/logging.conf"
 )

tests/unit/test_utils.py

@@ -19,6 +19,32 @@
 from rockoon import exception
 
 
+def test_find_key_paths():
+    assert {("a", "b")} == utils.find_key_paths(
+        {"a": {"b": {"c": {}, "d": {"e": {}}}}}, "c"
+    )
+    assert {("a", "b"), ("a", "b", "d", "e")} == utils.find_key_paths(
+        {"a": {"b": {"c": {}, "d": {"e": {"c": {}}}}}}, "c"
+    )
+    assert set() == utils.find_key_paths({"a": {}}, "c")
+    assert {tuple()} == utils.find_key_paths({"c": {}}, "c")
+    assert {("a", "f"), ("a", "b")} == utils.find_key_paths(
+        {"a": {"f": {"c": {}}, "b": {"c": {}}}}, "c"
+    )
+    assert {("b",)} == utils.find_key_paths(
+        {"a": {"f": {"d": "c"}}, "b": {"c": {"e": {}}}}, "c"
+    )
+    assert {("f",), ("a", "b")} == utils.find_key_paths(
+        {"f": {"c": {"g": "e"}}, "a": {"d": {}, "b": {"c": {}}}}, "c"
+    )
+    assert {("f",), ("a", "b"), ("a", "d")} == utils.find_key_paths(
+        {"f": {"c": {"g": "e"}}, "a": {"d": {"c": {}}, "b": {"c": {}}}}, "c"
+    )
+    assert {("f",)} == utils.find_key_paths(
+        {"f": {"c": []}, "a": [{"c": "d"}, {"g": "e"}]}, "c"
+    )
+
+
 def test_divide_into_groups_of():
     assert [["a", "b", "c"]] == utils.divide_into_groups_of(3, ["a", "b", "c"])
     assert [["a", "b"], ["c", "d"], ["e"]] == utils.divide_into_groups_of(