validate and fix port and portgroup names in Ironic to ensure they are prefixed with the node name.

Author: syedhaseebahmed

components/site-workflows/sensors/sensor-ironic-node-portgroup.yaml

@@ -0,0 +1,71 @@
+---
+apiVersion: argoproj.io/v1alpha1
+kind: Sensor
+metadata:
+  name: ironic-node-portgroup
+  annotations:
+    workflows.argoproj.io/title: Validate Portgroup Names from Ironic Events
+    workflows.argoproj.io/description: |+
+      Triggers on the following Ironic Events:
+
+      - baremetal.portgroup.create.end which happens when a baremetal portgroup is created
+
+      This sensor validates that portgroup names are prefixed with the node name.
+      If not, it automatically updates the portgroup name to include the prefix.
+
+      Resulting code should be very similar to:
+
+      ```
+      argo -n argo-events submit --from workflowtemplate/openstack-oslo-event \
+      -p event-json "JSON-payload"
+      ```
+
+      Defined in `workflows/argo-events/sensors/ironic-node-portgroup.yaml`
+spec:
+  dependencies:
+  - eventName: openstack
+    eventSourceName: openstack-ironic
+    name: ironic-dep
+    transform:
+      # the event is a string-ified JSON so we need to decode it
+      # replace the whole event body
+      jq: |
+        .body = (.body["oslo.message"] | fromjson)
+    filters:
+      # applies each of the items in data with 'and' but there's only one
+      dataLogicalOperator: "and"
+      data:
+        - path: "body.event_type"
+          type: "string"
+          value:
+            - "baremetal.portgroup.create.end"
+  template:
+    serviceAccountName: sensor-submit-workflow
+  triggers:
+    - template:
+        name: ironic-node-portgroup
+        # creates workflow object directly via k8s API
+        k8s:
+          operation: create
+          parameters:
+            # first parameter is the parsed oslo.message
+            - dest: spec.arguments.parameters.0.value
+              src:
+                dataKey: body
+                dependencyName: ironic-dep
+          source:
+            # create a workflow in argo-events prefixed with ironic-node-portgroup-
+            resource:
+              apiVersion: argoproj.io/v1alpha1
+              kind: Workflow
+              metadata:
+                generateName: ironic-node-portgroup-
+                namespace: argo-events
+              spec:
+                # defines the parameters being replaced above
+                arguments:
+                  parameters:
+                    - name: event-json
+                # references the workflow
+                workflowTemplateRef:
+                  name: openstack-oslo-event

python/understack-workflows/understack_workflows/main/openstack_oslo_event.py

@@ -15,6 +15,7 @@
 from understack_workflows.openstack.client import get_openstack_client
 from understack_workflows.oslo_event import ironic_node
 from understack_workflows.oslo_event import ironic_port
+from understack_workflows.oslo_event import ironic_portgroup
 from understack_workflows.oslo_event import keystone_project
 from understack_workflows.oslo_event import neutron_network
 from understack_workflows.oslo_event import neutron_subnet
@@ -67,6 +68,7 @@ class NoEventHandlerError(Exception):
     "baremetal.port.create.end": ironic_port.handle_port_create_update,
     "baremetal.port.update.end": ironic_port.handle_port_create_update,
     "baremetal.port.delete.end": ironic_port.handle_port_delete,
+    "baremetal.portgroup.create.end": ironic_portgroup.handle_portgroup_create,
     "baremetal.node.provision_set.end": ironic_node.handle_provision_end,
     "identity.project.created": keystone_project.handle_project_created,
     "identity.project.updated": keystone_project.handle_project_updated,

python/understack-workflows/understack_workflows/oslo_event/ironic_port.py

@@ -59,12 +59,64 @@ def from_event_dict(cls, data: dict) -> IronicPortEvent:
         )
 
 
+def _get_node_name(conn: Connection, node_uuid: str) -> str | None:
+    """Get the node name from Ironic by UUID."""
+    try:
+        node = conn.baremetal.get_node(node_uuid)  # pyright: ignore
+        return node.name if node else None
+    except Exception:
+        logger.exception("Failed to get node %s from Ironic", node_uuid)
+        return None
+
+
+def _should_fix_port_name(name: str, node_name: str) -> bool:
+    """Check if port name needs to be prefixed with node name."""
+    if not name:
+        return False
+    return not name.startswith(f"{node_name}-")
+
+
+def _fix_port_name_if_needed(conn: Connection, event: IronicPortEvent) -> None:
+    """Fix port name by prefixing with node name if needed."""
+    if not event.name:
+        logger.debug("Port %s has no name, skipping name validation", event.uuid)
+        return
+
+    # Get the node name
+    node_name = _get_node_name(conn, event.node_uuid)
+    if not node_name:
+        logger.error("Could not get node name for node %s", event.node_uuid)
+        return
+
+    # Check if name needs fixing
+    if not _should_fix_port_name(event.name, node_name):
+        logger.debug(
+            "Port %s name '%s' already has correct prefix", event.uuid, event.name
+        )
+        return
+
+    # Fix the name by prefixing with node name
+    new_name = f"{node_name}-{event.name}"
+    logger.info(
+        "Updating port %s name from '%s' to '%s'", event.uuid, event.name, new_name
+    )
+
+    try:
+        conn.baremetal.update_port(event.uuid, name=new_name)  # pyright: ignore
+        logger.info("Successfully updated port %s name", event.uuid)
+    except Exception:
+        logger.exception("Failed to update port %s name", event.uuid)
+
+
 def handle_port_create_update(
-    _conn: Connection, nautobot: Nautobot, event_data: dict
+    conn: Connection, nautobot: Nautobot, event_data: dict
 ) -> int:
     """Operates on an Ironic Port create and update event."""
     event = IronicPortEvent.from_event_dict(event_data)
 
+    # Check and fix port name if needed
+    _fix_port_name_if_needed(conn, event)
+
     logger.debug("looking up interface in nautobot by UUID: %s", event.uuid)
     intf = nautobot.dcim.interfaces.get(id=event.uuid)
     if not intf:

python/understack-workflows/understack_workflows/oslo_event/ironic_portgroup.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+from openstack.connection import Connection
+from pynautobot.core.api import Api as Nautobot
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class IronicPortgroupEvent:
+    uuid: str
+    name: str | None
+    node_uuid: str
+    address: str | None
+    mode: str | None
+
+    @classmethod
+    def from_event_dict(cls, data: dict) -> IronicPortgroupEvent:
+        payload = data.get("payload")
+        if payload is None:
+            raise Exception("Invalid event. No 'payload'")
+
+        # Extract the actual data from the nested ironic object structure
+        payload_data = payload.get("ironic_object.data")
+        if payload_data is None:
+            raise Exception("Invalid event. No 'ironic_object.data' in payload")
+
+        return IronicPortgroupEvent(
+            payload_data["uuid"],
+            payload_data.get("name"),
+            payload_data["node_uuid"],
+            payload_data.get("address"),
+            payload_data.get("mode"),
+        )
+
+
+def _get_node_name(conn: Connection, node_uuid: str) -> str | None:
+    """Get the node name from Ironic by UUID."""
+    try:
+        node = conn.baremetal.get_node(node_uuid)  # pyright: ignore
+        return node.name if node else None
+    except Exception:
+        logger.exception("Failed to get node %s from Ironic", node_uuid)
+        return None
+
+
+def _should_fix_portgroup_name(name: str | None, node_name: str) -> bool:
+    """Check if portgroup name needs to be prefixed with node name."""
+    if not name:
+        return False
+    return not name.startswith(f"{node_name}-")
+
+
+def handle_portgroup_create(
+    conn: Connection, _nautobot: Nautobot, event_data: dict
+) -> int:
+    """Handle Ironic Portgroup create event and fix name if needed."""
+    event = IronicPortgroupEvent.from_event_dict(event_data)
+
+    logger.info("Processing portgroup create event for %s", event.uuid)
+
+    # Get the node name
+    node_name = _get_node_name(conn, event.node_uuid)
+    if not node_name:
+        logger.error("Could not get node name for node %s", event.node_uuid)
+        return 1
+
+    # Check if name needs fixing
+    if not _should_fix_portgroup_name(event.name, node_name):
+        logger.info(
+            "Portgroup %s name '%s' already has correct prefix", event.uuid, event.name
+        )
+        return 0
+
+    # Fix the name by prefixing with node name
+    new_name = f"{node_name}-{event.name}"
+    logger.info(
+        "Updating portgroup %s name from '%s' to '%s'",
+        event.uuid,
+        event.name,
+        new_name,
+    )
+
+    try:
+        conn.baremetal.update_port_group(event.uuid, name=new_name)  # pyright: ignore
+        logger.info("Successfully updated portgroup %s name", event.uuid)
+        return 0
+    except Exception:
+        logger.exception("Failed to update portgroup %s name", event.uuid)
+        return 1