PUC-785: crud unvni group range with neutron-segment-range

Author: haseebsyed12

python/understack-workflows/pyproject.toml

@@ -51,6 +51,7 @@ undersync-device = "understack_workflows.main.undersync_device:main"
 enroll-server = "understack_workflows.main.enroll_server:main"
 bmc-password = "understack_workflows.main.print_bmc_password:main"
 bmc-kube-password = "understack_workflows.main.bmc_display_password:main"
+sync-network-segment-range = "understack_workflows.main.sync_ucvni_group_range:main"
 
 [tool.pytest.ini_options]
 minversion = "6.0"

python/understack-workflows/tests/test_sync_ucvni_group_range.py

@@ -0,0 +1,107 @@
+from argparse import Namespace
+from unittest import mock
+from unittest.mock import Mock
+from unittest.mock import patch
+
+import pytest
+
+from understack_workflows.main.sync_ucvni_group_range import _EXIT_API_ERROR
+from understack_workflows.main.sync_ucvni_group_range import _EXIT_EVENT_UNKNOWN
+from understack_workflows.main.sync_ucvni_group_range import _EXIT_SUCCESS
+from understack_workflows.main.sync_ucvni_group_range import SegmentRangeEvent
+from understack_workflows.main.sync_ucvni_group_range import handle_event
+from understack_workflows.main.sync_ucvni_group_range import main
+from understack_workflows.main.sync_ucvni_group_range import modify_range
+
+
+@pytest.mark.parametrize(
+    "action,new_range,existing_range,segment_range_note,expected",
+    [
+        (SegmentRangeEvent.CREATE, "20-30", "", None, "20-30"),
+        (SegmentRangeEvent.CREATE, "20-30", "10-15", None, "10-15,20-30"),
+        (SegmentRangeEvent.DELETE, "", "10-15,20-30", "20-30", "10-15"),
+        (SegmentRangeEvent.DELETE, "", "10-30", "15-25", "10-14,26-30"),
+        (SegmentRangeEvent.DELETE, "", "10-15,20-30", "invalid", "10-15,20-30"),
+        (SegmentRangeEvent.UPDATE, "40-50", "10-20,30-35", "30-35", "10-20,40-50"),
+        (SegmentRangeEvent.UPDATE, "30-35", "10-20,40-50", "40-50", "10-20,30-35"),
+        (SegmentRangeEvent.UPDATE, "15-18", "10-20", "12-16", "10-11,17-20,15-18"),
+    ],
+)
+def test_modify_range(action, new_range, existing_range, segment_range_note, expected):
+    mock_notes_endpoint = Mock()
+    mock_notes_endpoint.get.return_value = Mock(note=segment_range_note)
+
+    result = modify_range(
+        action,
+        new_range,
+        existing_range,
+        segment_range_id="segment123",
+        notes_endpoint=mock_notes_endpoint,
+    )
+
+    result_parts = sorted(result.split(",")) if result else []
+    expected_parts = sorted(expected.split(",")) if expected else []
+
+    assert result_parts == expected_parts
+
+
+@mock.patch(
+    "understack_workflows.main.sync_ucvni_group_range.credential",
+    return_value="dummy-token",
+)
+@mock.patch("understack_workflows.main.sync_ucvni_group_range.Nautobot")
+def test_handle_event_ucvni_group_not_found(mock_nautobot_class, mock_credential):
+    mock_nautobot = Mock()
+    mock_ucvni_groups = Mock()
+    mock_ucvni_groups.get.return_value = None  # Simulate UCVNI group not found
+
+    mock_nautobot.session.plugins.undercloud_vni.ucvni_groups = mock_ucvni_groups
+    mock_nautobot.session.extras.notes = Mock()
+
+    mock_nautobot_class.return_value = mock_nautobot
+
+    segment_args = Namespace(
+        nautobot_token=None,
+        nautobot_url="http://mocked-nautobot",
+        segment_name="fake-segment",
+    )
+    result = handle_event(segment_args)
+    assert result == _EXIT_API_ERROR
+    mock_ucvni_groups.get.assert_called_once_with("fake-segment")
+
+
+@pytest.mark.parametrize(
+    "event,handle_event_return,expected_exit_code",
+    [
+        (SegmentRangeEvent.CREATE, _EXIT_SUCCESS, _EXIT_SUCCESS),
+        ("UNKNOWN_EVENT", None, _EXIT_EVENT_UNKNOWN),
+    ],
+)
+@patch("understack_workflows.main.sync_ucvni_group_range.argument_parser")
+@patch("understack_workflows.main.sync_ucvni_group_range.logger")
+@patch("understack_workflows.main.sync_ucvni_group_range.handle_event")
+def test_main(
+    mock_handle_event,
+    mock_logger,
+    mock_argument_parser,
+    event,
+    handle_event_return,
+    expected_exit_code,
+):
+    mock_args = Namespace(event=event)
+    mock_argument_parser.return_value.parse_args.return_value = mock_args
+
+    if event != "UNKNOWN_EVENT":
+        mock_handle_event.return_value = handle_event_return
+
+    result = main()
+
+    assert result == expected_exit_code
+
+    if event == "UNKNOWN_EVENT":
+        mock_logger.error.assert_called_once_with(
+            "Cannot handle event: %s", "UNKNOWN_EVENT"
+        )
+        mock_handle_event.assert_not_called()
+    else:
+        mock_handle_event.assert_called_once_with(segment_args=mock_args)

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

@@ -0,0 +1,219 @@
+import argparse
+import logging
+from argparse import Namespace
+from enum import StrEnum
+from typing import cast
+
+import requests
+from pynautobot.core.endpoint import DetailEndpoint
+from pynautobot.core.endpoint import Endpoint
+from pynautobot.core.response import Record
+from requests import RequestException
+
+from understack_workflows.helpers import credential
+from understack_workflows.helpers import parser_nautobot_args
+from understack_workflows.helpers import setup_logger
+from understack_workflows.nautobot import Nautobot
+
+logger = setup_logger(__name__, level=logging.INFO)
+
+_EXIT_SUCCESS = 0
+_EXIT_API_ERROR = 1
+_EXIT_EVENT_UNKNOWN = 2
+
+
+class SegmentRangeEvent(StrEnum):
+    CREATE = "network_segment_range.create.end"
+    UPDATE = "network_segment_range.update.end"
+    DELETE = "network_segment_range.delete.end"
+
+
+def argument_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Handle Network Segment Range Events")
+    parser.add_argument(
+        "event", type=SegmentRangeEvent, choices=list(SegmentRangeEvent)
+    )
+    parser.add_argument("segment_name", type=str, help="Segment name")
+    parser.add_argument("network_type", type=str, help="Network type")
+    parser.add_argument("segment_range_id", type=str, help="Segment range ID")
+    parser.add_argument("segment_min_range", type=int, help="Segment minimum range")
+    parser.add_argument("segment_max_range", type=int, help="Segment maximum range")
+    return parser_nautobot_args(parser)
+
+
+def _remove_subrange(
+    ranges: list[str], segment_range_id: str, notes_endpoint
+) -> list[str]:
+    range_record: Record = cast(Record, notes_endpoint.get(segment_range_id))
+    range_to_remove: str | None = range_record.note
+
+    """Remove sub-range and adjust existing ranges."""
+    if not range_to_remove:
+        return ranges
+
+    updated_ranges = []
+    try:
+        remove_start, remove_end = map(int, range_to_remove.split("-"))
+    except ValueError:
+        return ranges  # Return unchanged if range_to_remove is invalid
+
+    for r in ranges:
+        start, end = map(int, r.split("-"))
+
+        # If it's an exact match, remove it
+        if start == remove_start and end == remove_end:
+            continue
+
+        # If there's no overlap, keep the range
+        if end < remove_start or start > remove_end:
+            updated_ranges.append(r)
+        else:
+            # Handle partial overlap by splitting
+            if start < remove_start:
+                updated_ranges.append(f"{start}-{remove_start - 1}")
+            if end > remove_end:
+                updated_ranges.append(f"{remove_end + 1}-{end}")
+
+    return updated_ranges
+
+
+def modify_range(
+    action: SegmentRangeEvent,
+    new_range: str,
+    existing_range: str | None,
+    segment_range_id: str,
+    notes_endpoint: Endpoint,
+) -> str:
+    ranges = existing_range.split(",") if existing_range else []
+
+    match action:
+        case SegmentRangeEvent.CREATE:
+            ranges.append(new_range)
+
+        case SegmentRangeEvent.DELETE:
+            ranges = _remove_subrange(
+                ranges=ranges,
+                segment_range_id=segment_range_id,
+                notes_endpoint=notes_endpoint,
+            )
+
+        case SegmentRangeEvent.UPDATE:
+            # Remove old range completely or adjust if overlapping
+            ranges = _remove_subrange(
+                ranges,
+                segment_range_id=segment_range_id,
+                notes_endpoint=notes_endpoint,
+            )
+
+            # Add the new updated range
+            ranges.append(new_range)
+
+    return ",".join(ranges)
+
+
+def update_ucvni_range(
+    segment_args: Namespace,
+    notes_endpoint: Endpoint,
+    ucvni_group: Record,
+) -> bool:
+    action: SegmentRangeEvent = segment_args.event
+    requested_range = (
+        f"{segment_args.segment_min_range}-{segment_args.segment_max_range}"
+    )
+    new_range = modify_range(
+        action=action,
+        existing_range=ucvni_group.range,
+        new_range=requested_range,
+        segment_range_id=segment_args.segment_range_id,
+        notes_endpoint=notes_endpoint,
+    )
+    try:
+        is_updated = ucvni_group.update(data={"range": new_range})
+        if is_updated:
+            capture_segment_range_in_notes(
+                ucvni_group_notes_endpoint=ucvni_group.notes,
+                notes_endpoint=notes_endpoint,
+                segment_range_id=segment_args.segment_range_id,
+                segment_range=requested_range,
+                action=action,
+            )
+        return is_updated
+    except requests.RequestException:
+        logger.exception(
+            "Failed to update range %s of segment-id %s",
+            new_range,
+            segment_args.segment_range_id,
+        )
+        return False
+
+
+def capture_segment_range_in_notes(
+    ucvni_group_notes_endpoint: DetailEndpoint,
+    notes_endpoint: Endpoint,
+    segment_range_id: str,
+    segment_range: str,
+    action: str,
+):
+    try:
+        if action == SegmentRangeEvent.UPDATE:
+            notes_endpoint.update(id=segment_range_id, data={"note": segment_range})
+        elif action == SegmentRangeEvent.DELETE:
+            notes_endpoint.delete([segment_range_id])
+        else:
+            ucvni_group_notes_endpoint.create(
+                {"id": segment_range_id, "note": segment_range}
+            )
+    except RequestException as e:
+        logger.exception(
+            "error calling notes api action %s for segment-id: %s ",
+            action,
+            segment_range_id,
+        )
+        raise e
+
+
+def handle_event(segment_args: Namespace) -> int:
+    nb_token = segment_args.nautobot_token or credential("nb-token", "token")
+    try:
+        nautobot: Nautobot = Nautobot(
+            segment_args.nautobot_url, nb_token, logger=logger
+        )
+        ucvni_group_endpoint: Endpoint = (
+            nautobot.session.plugins.undercloud_vni.ucvni_groups
+        )
+        notes_endpoint: Endpoint = nautobot.session.extras.notes
+    except requests.exceptions.ConnectTimeout as e:
+        logger.error("Network error while connecting to Nautobot: %s", str(e))
+        return _EXIT_API_ERROR
+
+    ucvni_group: Record = cast(
+        Record, ucvni_group_endpoint.get(segment_args.segment_name)
+    )
+    if ucvni_group is None:
+        logger.error("No UCVNI group found for segment %s", {segment_args.segment_name})
+        return _EXIT_API_ERROR
+
+    return (
+        _EXIT_SUCCESS
+        if update_ucvni_range(
+            segment_args=segment_args,
+            ucvni_group=ucvni_group,
+            notes_endpoint=notes_endpoint,
+        )
+        else _EXIT_API_ERROR
+    )
+
+
+def main() -> int:
+    args = argument_parser().parse_args()
+
+    event: SegmentRangeEvent = args.event
+    if event not in [
+        SegmentRangeEvent.CREATE,
+        SegmentRangeEvent.UPDATE,
+        SegmentRangeEvent.DELETE,
+    ]:
+        logger.error("Cannot handle event: %s", event)
+        return _EXIT_EVENT_UNKNOWN
+
+    return handle_event(segment_args=args)

workflows/argo-events/workflowtemplates/neutron-event-network-segment-range.yaml

@@ -0,0 +1,63 @@
+apiVersion: argoproj.io/v1alpha1
+metadata:
+  name: neutron-event-network-segment-range
+  annotations:
+    workflows.argoproj.io/title: CRUD UCVNI Group range with network-segment-range
+    workflows.argoproj.io/description: |
+      Updates Nautobot UCVNI Group range field from a network-segment-range min, max values.
+
+      To test this workflow you can run it with the following:
+
+      ```
+      argo -n argo-events submit --from workflowtemplate/neutron-event-network-segment-range \
+      -p event_type network_segment_range.create.end -p segment_min_range=1800 segment_max_range=3799
+      ```
+
+      Defined in `workflows/argo-events/workflowtemplates/neutron-event-network-segment-range.yaml`
+kind: WorkflowTemplate
+spec:
+  entrypoint: sync-network-segment-range
+  serviceAccountName: workflow
+  arguments:
+    parameters:
+      - name: event_type
+      - name: segment_name
+      - name: network_type
+      - name: segment_range_id
+      - name: segment_min_range
+      - name: segment_max_range
+  templates:
+    - name: sync-network-segment-range
+      inputs:
+        parameters:
+          - name: event_type
+          - name: segment_name
+          - name: network_type
+          - name: segment_range_id
+          - name: segment_min_range
+          - name: segment_max_range
+      container:
+        image: ghcr.io/rackerlabs/understack/ironic-nautobot-client:latest
+        command:
+          - sync-network-segment-range
+        args:
+          - "{{inputs.parameters.event_type}}"
+          - "{{inputs.parameters.segment_name}}"
+          - "{{inputs.parameters.network_type}}"
+          - "{{inputs.parameters.segment_range_id}}"
+          - "{{inputs.parameters.segment_min_range}}"
+          - "{{inputs.parameters.segment_max_range}}"
+        volumeMounts:
+          - mountPath: /etc/nb-token/
+            name: nb-token
+            readOnly: true
+          - mountPath: /etc/openstack
+            name: openstack-svc-acct
+            readOnly: true
+      volumes:
+        - name: nb-token
+          secret:
+            secretName: nautobot-token
+        - name: openstack-svc-acct
+          secret:
+            secretName: openstack-svc-acct