actually use the Nautobot response now

skrobul · skrobul · commit 90fe7f9c4c77 · 2025-09-01T13:26:10.000+01:00
diff --git a/python/understack-workflows/understack_workflows/main/netapp_configure_net.py b/python/understack-workflows/understack_workflows/main/netapp_configure_net.py
@@ -4,17 +4,21 @@
 import uuid
 from dataclasses import dataclass
 
-import pynautobot
-
 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
+from understack_workflows.netapp_manager import NetappIPInterfaceConfig
+from understack_workflows.netapp_manager import NetAppManager
 
 logger = setup_logger(__name__, level=logging.INFO)
 
-# GraphQL query to retrieve virtual machine network information as specified in requirements
-VIRTUAL_MACHINES_QUERY = "query ($device_names: [String]){virtual_machines(name: $device_names) {interfaces { name ip_addresses{ address } tagged_vlans { vid }}}}"
+# GraphQL query to retrieve virtual machine network information as specified in
+# requirements
+VIRTUAL_MACHINES_QUERY = (
+    "query ($device_names: [String]){virtual_machines(name: $device_names) "
+    "{interfaces { name ip_addresses{ address } tagged_vlans { vid }}}}"
+)
 
 
 @dataclass
@@ -28,32 +32,39 @@ def from_graphql_interface(cls, interface_data):
         """Create InterfaceInfo from GraphQL interface data with validation.
 
         Args:
-            interface_data: GraphQL interface data containing name, ip_addresses, and tagged_vlans
+            interface_data: GraphQL interface data containing name,
+                            ip_addresses, and tagged_vlans
 
         Returns:
             InterfaceInfo: Validated interface information
 
         Raises:
             ValueError: If interface has zero or multiple IP addresses or VLANs
         """
-        name = interface_data.get('name', '')
-        ip_addresses = interface_data.get('ip_addresses', [])
-        tagged_vlans = interface_data.get('tagged_vlans', [])
+        name = interface_data.get("name", "")
+        ip_addresses = interface_data.get("ip_addresses", [])
+        tagged_vlans = interface_data.get("tagged_vlans", [])
 
         # Validate exactly one IP address
         if len(ip_addresses) == 0:
             raise ValueError(f"Interface '{name}' has no IP addresses")
         elif len(ip_addresses) > 1:
-            raise ValueError(f"Interface '{name}' has multiple IP addresses: {[ip['address'] for ip in ip_addresses]}")
+            raise ValueError(
+                f"Interface '{name}' has multiple IP addresses:"
+                f" {[ip['address'] for ip in ip_addresses]}"
+            )
 
         # Validate exactly one tagged VLAN
         if len(tagged_vlans) == 0:
             raise ValueError(f"Interface '{name}' has no tagged VLANs")
         elif len(tagged_vlans) > 1:
-            raise ValueError(f"Interface '{name}' has multiple tagged VLANs: {[vlan['vid'] for vlan in tagged_vlans]}")
+            raise ValueError(
+                f"Interface '{name}' has multiple tagged VLANs:"
+                f" {[vlan['vid'] for vlan in tagged_vlans]}"
+            )
 
-        address = ip_addresses[0]['address']
-        vlan = tagged_vlans[0]['vid']
+        address = ip_addresses[0]["address"]
+        vlan = tagged_vlans[0]["vid"]
 
         return cls(name=name, address=address, vlan=vlan)
 
@@ -76,7 +87,7 @@ def from_graphql_vm(cls, vm_data):
             ValueError: If any interface validation fails
         """
         interfaces = []
-        for interface_data in vm_data.get('interfaces', []):
+        for interface_data in vm_data.get("interfaces", []):
             interface_info = InterfaceInfo.from_graphql_interface(interface_data)
             interfaces.append(interface_info)
 
@@ -107,15 +118,24 @@ def validate_and_normalize_uuid(value: str) -> str:
 def argument_parser():
     """Parse command line arguments for netapp network configuration."""
     parser = argparse.ArgumentParser(
-        description="Query Nautobot for virtual machine network configuration based on project ID",
+        description="Query Nautobot for SVM network configuration and create "
+        "NetApp interfaces based on project ID",
     )
 
     # Add required project_id argument with UUID validation
     parser.add_argument(
         "--project-id",
         type=validate_and_normalize_uuid,
         required=True,
-        help="OpenStack project ID (UUID) to query for virtual machine network configuration"
+        help="OpenStack project ID (UUID) to query for SVM configuration",
+    )
+
+    parser.add_argument(
+        "--netapp-config-path",
+        type=str,
+        default="/etc/netapp/netapp_nvme.conf",
+        help="Path to NetApp config with credentials "
+        "(default: /etc/netapp/netapp_nvme.conf)",
     )
 
     # Add Nautobot connection arguments using the helper
@@ -151,43 +171,54 @@ def execute_graphql_query(nautobot_client: Nautobot, project_id: str) -> dict:
     device_name = construct_device_name(project_id)
     variables = {"device_names": [device_name]}
 
-    logger.debug(f"Executing GraphQL query for device: {device_name}")
-    logger.debug(f"Query variables: {variables}")
+    logger.debug("Executing GraphQL query for device: %s", device_name)
+    logger.debug("Query variables: %s", variables)
 
     # Execute the GraphQL query
     try:
-        result = nautobot_client.session.graphql.query(query=VIRTUAL_MACHINES_QUERY, variables=variables)
+        result = nautobot_client.session.graphql.query(
+            query=VIRTUAL_MACHINES_QUERY, variables=variables
+        )
     except Exception as e:
-        logger.error(f"Failed to execute GraphQL query: {e}")
+        logger.error("Failed to execute GraphQL query: %s", e)
         raise Exception(f"GraphQL query execution failed: {e}") from e
 
     # Check for GraphQL errors in response
     if not result.json:
         raise Exception("GraphQL query returned no data")
 
     if result.json.get("errors"):
-        error_messages = [error.get("message", str(error)) for error in result.json["errors"]]
+        error_messages = [
+            error.get("message", str(error)) for error in result.json["errors"]
+        ]
         error_details = "; ".join(error_messages)
-        logger.error(f"GraphQL query returned errors: {error_details}")
+        logger.error("GraphQL query returned errors: %s", error_details)
         raise Exception(f"GraphQL query failed with errors: {error_details}")
 
     # Log successful query execution
     data = result.json.get("data", {})
     vm_count = len(data.get("virtual_machines", []))
-    logger.info(f"GraphQL query successful. Found {vm_count} virtual machine(s) for device: {device_name}")
+    logger.info(
+        "GraphQL query successful. Found %s virtual machine(s) for device: %s",
+        vm_count,
+        device_name,
+    )
 
     return result.json
 
 
-def validate_and_transform_response(graphql_response: dict) -> list[VirtualMachineNetworkInfo]:
+def validate_and_transform_response(
+    graphql_response: dict,
+) -> list[VirtualMachineNetworkInfo]:
     """Validate and transform GraphQL response into structured data objects.
 
     Args:
         graphql_response: Complete GraphQL response containing data and
             potential errors
 
     Returns:
-        list[VirtualMachineNetworkInfo]: List of validated virtual machine network information
+        list[VirtualMachineNetworkInfo]: List of validated SVM network
+            information
 
     Raises:
         ValueError: If any interface validation fails
@@ -205,17 +236,22 @@ def validate_and_transform_response(graphql_response: dict) -> list[VirtualMachi
         try:
             vm_network_info = VirtualMachineNetworkInfo.from_graphql_vm(vm_data)
             vm_network_infos.append(vm_network_info)
-            logger.debug(f"Successfully validated VM with {len(vm_network_info.interfaces)} interfaces")
+            logger.debug(
+                "Successfully validated VM with %s interfaces",
+                len(vm_network_info.interfaces),
+            )
         except ValueError as e:
-            logger.error(f"Interface validation failed: {e}")
+            logger.error("Interface validation failed: %s", e)
             raise ValueError(f"Data validation error: {e}") from e
 
-    logger.info(f"Successfully validated {len(vm_network_infos)} virtual machine(s)")
+    logger.info("Successfully validated %s virtual machine(s)", len(vm_network_infos))
     return vm_network_infos
 
 
-def do_action(nautobot_client: Nautobot, project_id: str) -> tuple[dict, list[VirtualMachineNetworkInfo]]:
-    """Execute the main GraphQL query and process results.
+def do_action(
+    nautobot_client: Nautobot, netapp_manager: NetAppManager, project_id: str
+) -> tuple[dict, list[VirtualMachineNetworkInfo]]:
+    """Execute main GraphQL query, process results, and create NetApp interfaces.
 
     This function orchestrates the workflow by:
     1. Executing GraphQL query using constructed device name
@@ -226,6 +262,7 @@ def do_action(nautobot_client: Nautobot, project_id: str) -> tuple[dict, list[Vi
 
     Args:
         nautobot_client: Nautobot API client instance
+        netapp_manager: NetAppManager API client for creating LIF interfaces
         project_id: OpenStack project ID to query for
 
     Returns:
@@ -242,7 +279,10 @@ def do_action(nautobot_client: Nautobot, project_id: str) -> tuple[dict, list[Vi
     """
     try:
         # Execute GraphQL query using constructed device name
-        logger.info(f"Querying Nautobot for virtual machine network configuration (project_id: {project_id})")
+        logger.info(
+            "Querying Nautobot for SVM network configuration (project_id: %s)",
+            project_id,
+        )
         raw_response = execute_graphql_query(nautobot_client, project_id)
 
         # Process and validate query results
@@ -253,33 +293,75 @@ def do_action(nautobot_client: Nautobot, project_id: str) -> tuple[dict, list[Vi
         device_name = construct_device_name(project_id)
         if validated_data:
             total_interfaces = sum(len(vm.interfaces) for vm in validated_data)
-            logger.info(f"Successfully processed {len(validated_data)} virtual machine(s) with {total_interfaces} total interfaces for device: {device_name}")
+            logger.info(
+                "Successfully processed %d virtual machine(s) with %d total "
+                "interfaces for device: %s",
+                len(validated_data),
+                total_interfaces,
+                device_name,
+            )
         else:
-            logger.warning(f"No virtual machines found for device: {device_name}")
-
-        # Return structured data objects
-        return raw_response, validated_data
+            logger.warning("No virtual machines found for device: %s", device_name)
 
     except ValueError as e:
         # Handle data validation error scenarios with exit code 3
-        logger.error(f"Data validation failed: {e}")
+        logger.error("Data validation failed: %s", e)
         raise SystemExit(3) from e
 
     except Exception as e:
         error_msg = str(e)
 
         # Handle GraphQL-specific error scenarios with exit code 2
         if "graphql" in error_msg.lower() or "query" in error_msg.lower():
-            logger.error(f"GraphQL query failed: {error_msg}")
+            logger.error("GraphQL query failed: %s", error_msg)
             raise SystemExit(2) from e
 
         # Handle other unexpected errors with exit code 2 (query-related)
         else:
-            logger.error(f"Nautobot error: {error_msg}")
+            logger.error("Nautobot error: %s", error_msg)
             raise SystemExit(2) from e
 
+    if validated_data:
+        netapp_create_interfaces(netapp_manager, validated_data[0], project_id)
+
+    # Return structured data objects
+    return raw_response, validated_data
+
+
+def netapp_create_interfaces(
+    mgr: NetAppManager,
+    nautobot_response: VirtualMachineNetworkInfo,
+    project_id: str,
+) -> None:
+    """Create NetApp LIF interfaces based on Nautobot VM network configuration.
+
+    This function converts the validated Nautobot response into NetApp interface
+    configurations and creates the corresponding LIF (Logical Interface) on the
+    NetApp storage system.
 
-def format_and_display_output(raw_response: dict, structured_data: list[VirtualMachineNetworkInfo]) -> None:
+    Args:
+        mgr: NetAppManager instance for creating LIF interfaces
+        nautobot_response: Validated virtual machine network information from
+            Nautobot
+        project_id: OpenStack project ID for logging and context
+
+    Returns:
+        None
+
+    Raises:
+        Exception: If SVM for the project is not found
+        NetAppRestError: If LIF creation fails on the NetApp system
+    """
+    configs = NetappIPInterfaceConfig.from_nautobot_response(nautobot_response)
+    for interface_config in configs:
+        logger.info("Creating LIF %s for project %s", interface_config.name, project_id)
+        mgr.create_lif(project_id, interface_config)
+    return
+
+
+def format_and_display_output(
+    raw_response: dict, structured_data: list[VirtualMachineNetworkInfo]
+) -> None:
     """Format and display query results with appropriate logging.
 
     This function handles:
@@ -304,14 +386,25 @@ def format_and_display_output(raw_response: dict, structured_data: list[VirtualM
     total_vms = len(structured_data)
     total_interfaces = sum(len(vm.interfaces) for vm in structured_data)
 
-    logger.info(f"Successfully retrieved network configuration for {total_vms} virtual machine(s)")
-    logger.info(f"Total interfaces found: {total_interfaces}")
+    logger.info(
+        "Successfully retrieved network configuration for %s virtual machine(s)",
+        total_vms,
+    )
+    logger.info("Total interfaces found: %s", total_interfaces)
 
     # Log detailed interface information at debug level
     for i, vm in enumerate(structured_data):
-        logger.debug(f"Virtual machine {i+1} has {len(vm.interfaces)} interface(s):")
+        logger.debug(
+            "SVM/Virtual machine %d has {len(vm.interfaces)} interface(s):",
+            i + 1,
+        )
         for interface in vm.interfaces:
-            logger.debug(f"  - Interface '{interface.name}': {interface.address} (VLAN {interface.vlan})")
+            logger.debug(
+                "  - Interface '%s': %s (VLAN %s)",
+                interface.name,
+                interface.address,
+                interface.vlan,
+            )
 
 
 def main():
@@ -341,11 +434,14 @@ def main():
         nb_token = args.nautobot_token or credential("nb-token", "token")
 
         # Establish Nautobot connection using parsed arguments
-        logger.info(f"Connecting to Nautobot at: {args.nautobot_url}")
+        logger.info("Connecting to Nautobot at: %s", args.nautobot_url)
         nautobot_client = Nautobot(args.nautobot_url, nb_token, logger=logger)
+        netapp_manager = NetAppManager(args.netapp_config_path)
 
         # Call do_action() with appropriate parameters
-        raw_response, structured_data = do_action(nautobot_client, args.project_id)
+        raw_response, structured_data = do_action(
+            nautobot_client, netapp_manager, args.project_id
+        )
 
         # Format and display output
         format_and_display_output(raw_response, structured_data)
@@ -360,7 +456,7 @@ def main():
 
     except Exception as e:
         # Handle connection errors and other unexpected errors with exit code 1
-        logger.error(f"Connection or initialization error: {e}")
+        logger.error("Connection or initialization error: %s", e)
         return 1
 
 
diff --git a/python/understack-workflows/understack_workflows/netapp_manager.py b/python/understack-workflows/understack_workflows/netapp_manager.py
@@ -6,6 +6,7 @@
 import re
 from dataclasses import dataclass
 from functools import cached_property
+from typing import TYPE_CHECKING
 
 import urllib3
 from netapp_ontap import config
@@ -20,7 +21,9 @@
 from netapp_ontap.resources import Volume
 
 from understack_workflows.helpers import setup_logger
-from understack_workflows.main.netapp_configure_net import VirtualMachineNetworkInfo
+
+if TYPE_CHECKING:
+    from understack_workflows.main.netapp_configure_net import VirtualMachineNetworkInfo
 
 logger = setup_logger(__name__)
 
@@ -64,7 +67,7 @@ def desired_node_number(self) -> int:
             raise ValueError("Cannot determine node index from name %s", self.name)
 
     @classmethod
-    def from_nautobot_response(cls, response: VirtualMachineNetworkInfo):
+    def from_nautobot_response(cls, response: "VirtualMachineNetworkInfo"):
         result = []
         for interface in response.interfaces:
             address, _ = interface.address.split("/")
