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

@@ -98,9 +98,11 @@ def add_subport_to_trunk(shared_port: PortDict, segment: NetworkSegmentDict) ->
             },
         ]
     }
+    trunk_id = utils.fetch_network_node_trunk_id()
+
     utils.fetch_trunk_plugin().add_subports(
         context=n_context.get_admin_context(),
-        trunk_id=cfg.CONF.ml2_understack.network_node_trunk_uuid,
+        trunk_id=trunk_id,
         subports=subports,
     )
 
@@ -251,8 +253,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 uuid
 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,228 @@ def fetch_trunk_plugin() -> TrunkPlugin:
     return trunk_plugin
 
 
+def _is_uuid(value: str) -> bool:
+    """Check if a string is a UUID."""
+    try:
+        uuid.UUID(value)
+        return True
+    except ValueError:
+        return False
+
+
+def _get_gateway_agent_host(core_plugin, context):
+    """Get the host of an alive OVN Controller Gateway agent.
+
+    Args:
+        core_plugin: Neutron core plugin instance
+        context: Neutron context
+
+    Returns:
+        str: Gateway agent host (may be hostname or UUID)
+
+    Raises:
+        Exception: If no alive gateway agents found
+    """
+    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"],
+    )
+    return gateway_host
+
+
+def _resolve_gateway_host(gateway_host):
+    """Resolve gateway host if it's a baremetal UUID.
+
+    Args:
+        gateway_host: Gateway host (hostname or UUID)
+
+    Returns:
+        tuple: (resolved_hostname, original_uuid or None)
+
+    Raises:
+        Exception: If UUID resolution fails
+    """
+    if not _is_uuid(gateway_host):
+        return gateway_host, None
+
+    LOG.debug(
+        "Gateway host %s is a baremetal UUID, resolving to hostname via Ironic",
+        gateway_host,
+    )
+    gateway_node_uuid = gateway_host
+    ironic_client = IronicClient()
+    resolved_name = ironic_client.baremetal_node_name(gateway_node_uuid)
+
+    if not resolved_name:
+        raise Exception(
+            f"Failed to resolve baremetal node UUID {gateway_node_uuid} "
+            "to hostname via Ironic"
+        )
+
+    LOG.debug(
+        "Resolved gateway baremetal node %s to hostname %s",
+        gateway_node_uuid,
+        resolved_name,
+    )
+    return resolved_name, gateway_node_uuid
+
+
+def _find_ports_bound_to_hosts(context, host_filters):
+    """Find ports bound to any of the specified hosts.
+
+    Args:
+        context: Neutron context
+        host_filters: List of hostnames/UUIDs to match
+
+    Returns:
+        list: Port objects bound to the specified hosts
+
+    Raises:
+        Exception: If no ports found
+    """
+    LOG.debug("Searching for ports bound to hosts: %s", host_filters)
+
+    # Get all ports and filter by binding_host_id
+    # Note: Port.get_objects doesn't support filtering by binding_host_id directly
+    all_ports = port_obj.Port.get_objects(context)
+    gateway_ports = []
+
+    for port in all_ports:
+        # Check if port has bindings and get the host
+        binding_host = None
+        if port.bindings:
+            binding_host = port.bindings[0].host
+
+        # Match against host_filters
+        if binding_host and binding_host in host_filters:
+            gateway_ports.append(port)
+            LOG.debug("Found port %s bound to gateway host %s", port.id, binding_host)
+
+    if not gateway_ports:
+        raise Exception(
+            f"No ports found bound to gateway hosts (searched for: {host_filters})"
+        )
+
+    LOG.debug("Found %d port(s) bound to gateway host", len(gateway_ports))
+    return gateway_ports
+
+
+def _find_trunk_by_port_ids(context, port_ids, gateway_host):
+    """Find trunk whose parent port is in the given port IDs.
+
+    Args:
+        context: Neutron context
+        port_ids: List of port IDs to check
+        gateway_host: Gateway hostname for logging
+
+    Returns:
+        str: Trunk UUID
+
+    Raises:
+        Exception: If no matching trunk found
+    """
+    trunks = trunk_obj.Trunk.get_objects(context)
+
+    if not trunks:
+        raise Exception("No trunks found in the system")
+
+    LOG.debug("Checking %d trunk(s) for parent ports in gateway ports", len(trunks))
+
+    for trunk in trunks:
+        if trunk.port_id in port_ids:
+            LOG.info(
+                "Found network node trunk: %s (parent_port: %s, host: %s)",
+                trunk.id,
+                trunk.port_id,
+                gateway_host,
+            )
+            return str(trunk.id)
+
+    # No matching trunk found
+    raise Exception(
+        f"Unable to find network node trunk on gateway host '{gateway_host}'. "
+        f"Found {len(port_ids)} port(s) bound to gateway host and "
+        f"{len(trunks)} trunk(s) in system, but no trunk uses any of the "
+        f"gateway ports as parent port. "
+        "Please ensure a trunk exists with a parent port on the network node."
+    )
+
+
+_cached_network_node_trunk_id = None
+
+
+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. If host is a UUID, resolve it to hostname via Ironic (single call)
+    4. Query ports bound to that host
+    5. Find trunks that use those ports as parent ports
+
+    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:
+        >>> fetch_network_node_trunk_id()
+        '2e558202-0bd0-4971-a9f8-61d1adea0427'
+    """
+    global _cached_network_node_trunk_id
+    if _cached_network_node_trunk_id:
+        return _cached_network_node_trunk_id
+
+    context = n_context.get_admin_context()
+    core_plugin = directory.get_plugin()
+
+    if not core_plugin:
+        raise Exception("Unable to obtain core plugin")
+
+    # Step 1: Get gateway agent host
+    gateway_host = _get_gateway_agent_host(core_plugin, context)
+
+    # Step 2: Resolve gateway host if it's a UUID (single Ironic call)
+    gateway_host, gateway_node_uuid = _resolve_gateway_host(gateway_host)
+
+    # Step 3: Build host filters (both hostname and UUID if applicable)
+    host_filters = [gateway_host]
+    if gateway_node_uuid:
+        host_filters.append(gateway_node_uuid)
+
+    # Step 4: Find ports bound to gateway host
+    gateway_ports = _find_ports_bound_to_hosts(context, host_filters)
+
+    # Step 5: Find trunk using gateway ports
+    gateway_port_ids = [port.id for port in gateway_ports]
+    _cached_network_node_trunk_id = _find_trunk_by_port_ids(
+        context, gateway_port_ids, gateway_host
+    )
+    return _cached_network_node_trunk_id
+
+
 def allocate_dynamic_segment(
     network_id: str,
     network_type: str = "vlan",