dynamic lookup network nodeId

Author: syedhaseebahmed

python/neutron-understack/neutron_understack/config.py

@@ -50,13 +50,6 @@
             "is used to trunk all vlans used by a neutron router."
         ),
     ),
-    cfg.StrOpt(
-        "network_node_trunk_uuid",
-        help=(
-            "UUID of the trunk that is used to trunk all vlans used by a Neutron"
-            " router."
-        ),
-    ),
     cfg.StrOpt(
         "network_node_switchport_physnet",
         help=(

python/neutron-understack/neutron_understack/ironic.py

@@ -32,3 +32,10 @@ def _port_by_local_link(self, local_link_info: dict) -> BaremetalPort | None:
             )
         except StopIteration:
             return None
+
+    def baremetal_node_name(self, node_uuid: str) -> str | None:
+        try:
+            node = self.irclient.get_node(node_uuid)
+            return node.name if node else None
+        except Exception:
+            return None

python/neutron-understack/neutron_understack/routers.py

@@ -100,7 +100,7 @@ def add_subport_to_trunk(shared_port: PortDict, segment: NetworkSegmentDict) ->
     }
     utils.fetch_trunk_plugin().add_subports(
         context=n_context.get_admin_context(),
-        trunk_id=cfg.CONF.ml2_understack.network_node_trunk_uuid,
+        trunk_id=utils.fetch_network_node_trunk_id(),
         subports=subports,
     )
 
@@ -251,8 +251,7 @@ def handle_router_interface_removal(_resource, _event, trigger, payload) -> None
 
 def handle_subport_removal(port: Port) -> None:
     """Removes router's subport from a network node trunk."""
-    # trunk_id will be discovered dynamically at some point
-    trunk_id = cfg.CONF.ml2_understack.network_node_trunk_uuid
+    trunk_id = utils.fetch_network_node_trunk_id()
     LOG.debug("Router, Removing subport: %s(port)s", {"port": port})
     port_id = port["id"]
     try:

python/neutron-understack/neutron_understack/tests/test_routers.py

@@ -37,8 +37,8 @@ def test_when_successful(self, mocker):
         port = {"id": "port-123"}
         segment = {"segmentation_id": 42}
         mocker.patch(
-            "oslo_config.cfg.CONF.ml2_understack.network_node_trunk_uuid",
-            trunk_id,
+            "neutron_understack.utils.fetch_network_node_trunk_id",
+            return_value=trunk_id,
         )
         mocker.patch(
             "neutron_lib.context.get_admin_context", return_value="admin_context"
@@ -70,7 +70,8 @@ def test_when_successful(self, mocker):
 class TestHandleSubportRemoval:
     def test_when_successful(self, mocker, port_id, trunk_id):
         mocker.patch(
-            "oslo_config.cfg.CONF.ml2_understack.network_node_trunk_uuid", str(trunk_id)
+            "neutron_understack.utils.fetch_network_node_trunk_id",
+            return_value=str(trunk_id),
         )
         mock_remove = mocker.patch("neutron_understack.utils.remove_subport_from_trunk")
         port = {"id": str(port_id)}

python/neutron-understack/neutron_understack/tests/test_trunk.py

@@ -336,13 +336,13 @@ class TestCheckSubportsSegmentationId:
     def test_when_trunk_id_is_network_node_trunk_id(
         self,
         mocker,
-        oslo_config,
         understack_trunk_driver,
         trunk_id,
     ):
-        oslo_config.config(
-            network_node_trunk_uuid=str(trunk_id),
-            group="ml2_understack",
+        # Mock fetch_network_node_trunk_id to return the trunk_id
+        mocker.patch(
+            "neutron_understack.utils.fetch_network_node_trunk_id",
+            return_value=str(trunk_id),
         )
         # Mock to ensure the function returns early and doesn't call this
         allowed_ranges_mock = mocker.patch(
@@ -362,6 +362,11 @@ def test_when_segmentation_id_is_in_allowed_range(
         trunk_id,
         subport,
     ):
+        # Mock fetch_network_node_trunk_id to return a different trunk ID
+        mocker.patch(
+            "neutron_understack.utils.fetch_network_node_trunk_id",
+            return_value="different-trunk-id",
+        )
         allowed_ranges = mocker.patch(
             "neutron_understack.utils.allowed_tenant_vlan_id_ranges",
             return_value=[(1, 1500)],
@@ -380,6 +385,11 @@ def test_when_segmentation_id_is_not_in_allowed_range(
         trunk_id,
         subport,
     ):
+        # Mock fetch_network_node_trunk_id to return a different trunk ID
+        mocker.patch(
+            "neutron_understack.utils.fetch_network_node_trunk_id",
+            return_value="different-trunk-id",
+        )
         mocker.patch(
             "neutron_understack.utils.allowed_tenant_vlan_id_ranges",
             return_value=[(1, 1500)],

python/neutron-understack/neutron_understack/trunk.py

@@ -129,7 +129,7 @@ def _check_subports_segmentation_id(
         segment VLAN tags allocated to the subports. Therefore, there is no
         possibility of conflict with the native VLAN.
         """
-        if trunk_id == cfg.CONF.ml2_understack.network_node_trunk_uuid:
+        if trunk_id == utils.fetch_network_node_trunk_id():
             return
 
         ns_ranges = utils.allowed_tenant_vlan_id_ranges()

python/neutron-understack/neutron_understack/utils.py

@@ -1,7 +1,11 @@
+import logging
+import re
 from contextlib import contextmanager
 
+from neutron.common.ovn import constants as ovn_const
 from neutron.db import models_v2
 from neutron.objects import ports as port_obj
+from neutron.objects import trunk as trunk_obj
 from neutron.objects.network import NetworkSegment
 from neutron.objects.network_segment_range import NetworkSegmentRange
 from neutron.plugins.ml2.driver_context import portbindings
@@ -14,10 +18,13 @@
 from neutron_lib.plugins.ml2 import api
 from oslo_config import cfg
 
+from neutron_understack.ironic import IronicClient
 from neutron_understack.ml2_type_annotations import NetworkSegmentDict
 from neutron_understack.ml2_type_annotations import PortContext
 from neutron_understack.ml2_type_annotations import PortDict
 
+LOG = logging.getLogger(__name__)
+
 
 def fetch_port_object(port_id: str) -> port_obj.Port:
     context = n_context.get_admin_context()
@@ -101,6 +108,148 @@ def fetch_trunk_plugin() -> TrunkPlugin:
     return trunk_plugin
 
 
+def _is_uuid(value: str) -> bool:
+    """Check if a string is a UUID."""
+    uuid_pattern = re.compile(
+        r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+    )
+    return bool(uuid_pattern.match(value))
+
+
+def fetch_network_node_trunk_id() -> str:
+    """Dynamically discover the network node trunk ID via OVN Gateway agent.
+
+    This function discovers the network node trunk by:
+    1. Finding alive OVN Controller Gateway agents
+    2. Getting the host of the gateway agent
+    3. Finding trunks whose parent port is bound to that host
+       (resolving baremetal node UUIDs to names via Ironic if needed)
+    4. Returning the first matching trunk
+
+    The network node trunk is used to connect router networks to the
+    network node (OVN gateway) by adding subports for each VLAN.
+
+    Returns:
+        str: The UUID of the network node trunk
+
+    Raises:
+        Exception: If no gateway agent or suitable trunk is found
+
+    Example:
+        >>> trunk_id = fetch_network_node_trunk_id()
+        >>> print(trunk_id)
+        '2e558202-0bd0-4971-a9f8-61d1adea0427'
+    """
+    context = n_context.get_admin_context()
+    core_plugin = directory.get_plugin()
+
+    if not core_plugin:
+        raise Exception("Unable to obtain core plugin")
+
+    # Find OVN Controller Gateway agents that are alive
+    LOG.debug("Looking for OVN Controller Gateway agents")
+    gateway_agents = core_plugin.get_agents(
+        context,
+        filters={"agent_type": [ovn_const.OVN_CONTROLLER_GW_AGENT], "alive": [True]},
+    )
+
+    if not gateway_agents:
+        raise Exception(
+            "No alive OVN Controller Gateway agents found. "
+            "Please ensure the network node is running and the "
+            "OVN gateway agent is active."
+        )
+
+    # Use the first gateway agent's host
+    # TODO: In the future, support multiple gateway agents for HA
+    gateway_host = gateway_agents[0]["host"]
+    LOG.debug(
+        "Found OVN Gateway agent on host: %s (agent_id: %s)",
+        gateway_host,
+        gateway_agents[0]["id"],
+    )
+
+    # Get all trunks
+    trunks = trunk_obj.Trunk.get_objects(context)
+
+    if not trunks:
+        raise Exception("No trunks found in the system")
+
+    ironic_client = IronicClient()
+    # Find trunk whose parent port is bound to the gateway host
+    for trunk in trunks:
+        try:
+            parent_port = port_obj.Port.get_object(context, id=trunk.port_id)
+
+            if not parent_port or not parent_port.bindings:
+                LOG.debug(
+                    "Trunk %s: parent port %s has no bindings, skipping",
+                    trunk.id,
+                    trunk.port_id,
+                )
+                continue
+
+            binding = parent_port.bindings[0]
+            port_host = binding.host
+
+            # If port is bound to a UUID (baremetal node), resolve it to name
+            if _is_uuid(port_host):
+                LOG.debug(
+                    "Trunk %s: port bound to baremetal node UUID %s, resolving to name",
+                    trunk.id,
+                    port_host,
+                )
+                resolved_name = ironic_client.baremetal_node_name(port_host)
+                if resolved_name:
+                    LOG.debug(
+                        "Trunk %s: resolved baremetal node %s to name %s",
+                        trunk.id,
+                        port_host,
+                        resolved_name,
+                    )
+                    port_host = resolved_name
+                else:
+                    LOG.debug(
+                        "Trunk %s: failed to resolve baremetal node %s, skipping",
+                        trunk.id,
+                        port_host,
+                    )
+                    continue
+
+            # Compare resolved host with gateway host
+            if port_host == gateway_host:
+                LOG.info(
+                    "Found network node trunk: %s (parent_port: %s, host: %s)",
+                    trunk.id,
+                    trunk.port_id,
+                    gateway_host,
+                )
+                return str(trunk.id)
+            else:
+                LOG.debug(
+                    "Trunk %s: parent port bound to host %s (looking for %s), skipping",
+                    trunk.id,
+                    port_host,
+                    gateway_host,
+                )
+
+        except Exception as e:
+            LOG.debug(
+                "Error checking trunk %s: %s. Continuing to next trunk.",
+                trunk.id,
+                str(e),
+            )
+            continue
+
+    # If we get here, no suitable trunk was found
+    raise Exception(
+        f"Unable to find network node trunk on gateway host '{gateway_host}'. "
+        f"Found {len(trunks)} trunk(s) but none have a parent port "
+        f"bound to the gateway host. "
+        "Please ensure a trunk exists with a parent port on the network node."
+    )
+
+
 def allocate_dynamic_segment(
     network_id: str,
     network_type: str = "vlan",