osism 0.20250628.0__py3-none-any.whl → 0.20250709.0__py3-none-any.whl

osism/api.py

@@ -208,11 +208,11 @@ async def notifications_baremetal(notification: NotificationBaremetal) -> None:
 
 
 @app.post(
-    "/v1/switches/{identifier}/ztp/complete",
+    "/v1/sonic/{identifier}/ztp/complete",
     response_model=DeviceSearchResult,
-    tags=["switches"],
+    tags=["sonic"],
 )
-async def switches_ztp_complete(identifier: str) -> DeviceSearchResult:
+async def sonic_ztp_complete(identifier: str) -> DeviceSearchResult:
     """Mark a switch as ZTP complete by setting provision_state to active."""
     if not utils.nb:
         raise HTTPException(

osism/commands/baremetal.py

@@ -12,6 +12,7 @@ import yaml
 from openstack.baremetal import configdrive as configdrive_builder
 
 from osism.commands import get_cloud_connection
+from osism import utils
 
 
 class BaremetalList(Command):
@@ -169,16 +170,51 @@ class BaremetalDeploy(Command):
                 continue
             # NOTE: Prepare osism config drive
             try:
+                # Get default vars from NetBox local_context_data if available
+                default_vars = {}
+                if utils.nb:
+                    try:
+                        # Try to find device by name first
+                        device = utils.nb.dcim.devices.get(name=node.name)
+
+                        # If not found by name, try by inventory_hostname custom field
+                        if not device:
+                            devices = utils.nb.dcim.devices.filter(
+                                cf_inventory_hostname=node.name
+                            )
+                            if devices:
+                                device = devices[0]
+
+                        # Extract local_context_data if device found and has the field
+                        if (
+                            device
+                            and hasattr(device, "local_context_data")
+                            and device.local_context_data
+                        ):
+                            default_vars = device.local_context_data
+                            logger.info(
+                                f"Using NetBox local_context_data for node {node.name}"
+                            )
+                        else:
+                            logger.debug(
+                                f"No local_context_data found for node {node.name} in NetBox"
+                            )
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to fetch NetBox data for node {node.name}: {e}"
+                        )
+
                 playbook = []
                 play = {
                     "name": "Run bootstrap - part 2",
                     "hosts": "localhost",
                     "connection": "local",
                     "gather_facts": True,
-                    "vars": {},
+                    "vars": default_vars.copy(),
                     "roles": [
                         "osism.commons.hostname",
                         "osism.commons.hosts",
+                        "osism.commons.operator",
                     ],
                 }
                 play["vars"].update(
@@ -293,11 +329,6 @@ class BaremetalUndeploy(Command):
                         f"Node {node.name} ({node.id}) could not be moved to available state: {exc}"
                     )
                     continue
-                # NOTE: Ironic removes "instance_info" on undeploy. It was saved to "extra" during sync and needs to be refreshed here.
-                if "instance_info" in node["extra"]:
-                    node = conn.baremetal.update_node(
-                        node, instance_info=json.loads(node.extra["instance_info"])
-                    )
             else:
                 logger.warning(
                     f"Node {node.name} ({node.id}) not in supported provision state"

osism/commands/manage.py

@@ -1,8 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
 
-import json
-import os
-from datetime import datetime
 from re import findall
 from urllib.parse import urljoin
 
@@ -10,12 +7,10 @@ from cliff.command import Command
 import docker
 from jinja2 import Template
 from loguru import logger
-import paramiko
 import requests
 
 from osism.data import TEMPLATE_IMAGE_CLUSTERAPI, TEMPLATE_IMAGE_OCTAVIA
 from osism.tasks import openstack, ansible, handle_task
-from osism import utils
 
 SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.31", "1.32", "1.33"]
 
@@ -389,249 +384,3 @@ class Dnsmasq(Command):
             )
 
         return handle_task(task, wait, format="log", timeout=300)
-
-
-class Sonic(Command):
-    def get_parser(self, prog_name):
-        parser = super(Sonic, self).get_parser(prog_name)
-        parser.add_argument(
-            "hostname", type=str, help="Hostname of the SONiC switch to manage"
-        )
-        parser.add_argument(
-            "--reload",
-            action="store_true",
-            help="Execute config reload after config load to restart services",
-        )
-        return parser
-
-    def take_action(self, parsed_args):
-        hostname = parsed_args.hostname
-        reload_config = parsed_args.reload
-        today = datetime.now().strftime("%Y%m%d")
-
-        try:
-            # Get device from NetBox - try by name first, then by inventory_hostname
-            device = utils.nb.dcim.devices.get(name=hostname)
-            if not device:
-                # Try to find by inventory_hostname custom field
-                devices = utils.nb.dcim.devices.filter(cf_inventory_hostname=hostname)
-                if devices:
-                    device = devices[0]  # Take the first match
-                    logger.info(f"Device found by inventory_hostname: {device.name}")
-                else:
-                    logger.error(
-                        f"Device {hostname} not found in NetBox (searched by name and inventory_hostname)"
-                    )
-                    return 1
-
-            # Get device configuration from local_context_data
-            if (
-                not hasattr(device, "local_context_data")
-                or not device.local_context_data
-            ):
-                logger.error(f"Device {hostname} has no local_context_data in NetBox")
-                return 1
-
-            config_context = device.local_context_data
-
-            # Save config context to local /tmp directory
-            config_context_file = f"/tmp/config_db_{hostname}_{today}.json"
-            try:
-                with open(config_context_file, "w") as f:
-                    json.dump(config_context, f, indent=2)
-                logger.info(f"Config context saved to {config_context_file}")
-            except Exception as e:
-                logger.error(f"Failed to save config context: {e}")
-                return 1
-
-            # Extract SSH connection details
-            ssh_host = None
-            ssh_username = None
-
-            # Try to get SSH details from config context
-            if "management" in config_context:
-                mgmt = config_context["management"]
-                if "ip" in mgmt:
-                    ssh_host = mgmt["ip"]
-                if "username" in mgmt:
-                    ssh_username = mgmt["username"]
-
-            # Fallback: try to get OOB IP from NetBox
-            if not ssh_host:
-                from osism.tasks.conductor.netbox import get_device_oob_ip
-
-                oob_result = get_device_oob_ip(device)
-                if oob_result:
-                    ssh_host = oob_result[0]
-
-            if not ssh_host:
-                logger.error(f"No SSH host found for device {hostname}")
-                return 1
-
-            if not ssh_username:
-                ssh_username = "admin"  # Default SONiC username
-
-            # SSH private key path
-            ssh_key_path = "/ansible/secrets/id_rsa.operator"
-
-            if not os.path.exists(ssh_key_path):
-                logger.error(f"SSH private key not found at {ssh_key_path}")
-                return 1
-
-            logger.info(
-                f"Connecting to {hostname} ({ssh_host}) to backup SONiC configuration"
-            )
-
-            # Create SSH connection
-            ssh = paramiko.SSHClient()
-            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-            try:
-                # Connect with private key
-                ssh.connect(
-                    hostname=ssh_host,
-                    username=ssh_username,
-                    key_filename=ssh_key_path,
-                    timeout=30,
-                )
-
-                # Generate backup filename with date and increment on switch
-                base_backup_path = f"/home/admin/config_db_{hostname}_{today}"
-                backup_filename = f"{base_backup_path}_1.json"
-
-                # Find next available filename on switch
-                x = 1
-                while True:
-                    check_cmd = f"ls {base_backup_path}_{x}.json 2>/dev/null"
-                    stdin, stdout, stderr = ssh.exec_command(check_cmd)
-                    if stdout.read().decode().strip() == "":
-                        backup_filename = f"{base_backup_path}_{x}.json"
-                        break
-                    x += 1
-
-                logger.info(
-                    f"Backing up current configuration on switch to {backup_filename}"
-                )
-
-                # Backup current configuration on switch
-                backup_cmd = f"sudo cp /etc/sonic/config_db.json {backup_filename}"
-                stdin, stdout, stderr = ssh.exec_command(backup_cmd)
-                exit_status = stdout.channel.recv_exit_status()
-
-                if exit_status != 0:
-                    error_msg = stderr.read().decode()
-                    logger.error(
-                        f"Failed to backup configuration on switch: {error_msg}"
-                    )
-                    return 1
-
-                logger.info("Configuration backed up successfully on switch")
-
-                # Upload local config context to switch /tmp directory
-                switch_config_file = f"/tmp/config_db_{hostname}_current.json"
-                logger.info(
-                    f"Uploading config context to {switch_config_file} on switch"
-                )
-
-                # Use SFTP to upload the config context file
-                sftp = ssh.open_sftp()
-                try:
-                    sftp.put(config_context_file, switch_config_file)
-                    logger.info(
-                        f"Config context successfully uploaded to {switch_config_file} on switch"
-                    )
-                except Exception as e:
-                    logger.error(f"Failed to upload config context to switch: {e}")
-                    return 1
-                finally:
-                    sftp.close()
-
-                # Load and apply the new configuration
-                logger.info("Loading and applying new configuration on switch")
-
-                load_cmd = f"sudo config load -y {switch_config_file}"
-                stdin, stdout, stderr = ssh.exec_command(load_cmd)
-                exit_status = stdout.channel.recv_exit_status()
-
-                if exit_status != 0:
-                    error_msg = stderr.read().decode()
-                    logger.error(f"Failed to load configuration: {error_msg}")
-                    return 1
-
-                logger.info("Configuration loaded and applied successfully")
-
-                # Optionally reload configuration to restart services
-                config_operations_successful = True
-                if reload_config:
-                    logger.info("Reloading configuration to restart services")
-
-                    reload_cmd = "sudo config reload -y"
-                    stdin, stdout, stderr = ssh.exec_command(reload_cmd)
-                    exit_status = stdout.channel.recv_exit_status()
-
-                    if exit_status != 0:
-                        error_msg = stderr.read().decode()
-                        logger.error(f"Failed to reload configuration: {error_msg}")
-                        config_operations_successful = False
-                    else:
-                        logger.info("Configuration reloaded successfully")
-
-                # Save configuration only if load (and optionally reload) were successful
-                if config_operations_successful:
-                    logger.info("Saving configuration to persist changes")
-
-                    save_cmd = "sudo config save -y"
-                    stdin, stdout, stderr = ssh.exec_command(save_cmd)
-                    exit_status = stdout.channel.recv_exit_status()
-
-                    if exit_status != 0:
-                        error_msg = stderr.read().decode()
-                        logger.error(f"Failed to save configuration: {error_msg}")
-                        return 1
-
-                    logger.info("Configuration saved successfully")
-                else:
-                    logger.warning("Skipping config save due to reload failure")
-
-                # Delete the temporary configuration file
-                logger.info(f"Cleaning up temporary file {switch_config_file}")
-
-                delete_cmd = f"rm {switch_config_file}"
-                stdin, stdout, stderr = ssh.exec_command(delete_cmd)
-                exit_status = stdout.channel.recv_exit_status()
-
-                if exit_status != 0:
-                    error_msg = stderr.read().decode()
-                    logger.warning(f"Failed to delete temporary file: {error_msg}")
-                else:
-                    logger.info("Temporary file deleted successfully")
-
-                logger.info("SONiC configuration management completed successfully")
-                logger.info(f"- Config context saved locally to: {config_context_file}")
-                if reload_config and config_operations_successful:
-                    logger.info("- Configuration loaded, reloaded, and saved on switch")
-                elif config_operations_successful:
-                    logger.info("- Configuration loaded and saved on switch")
-                else:
-                    logger.info(
-                        "- Configuration loaded on switch (save skipped due to reload failure)"
-                    )
-                logger.info(f"- Backup created on switch: {backup_filename}")
-
-                return 0
-
-            except paramiko.AuthenticationException:
-                logger.error(f"Authentication failed for {ssh_host}")
-                return 1
-            except paramiko.SSHException as e:
-                logger.error(f"SSH connection failed: {e}")
-                return 1
-            except Exception as e:
-                logger.error(f"Unexpected error during SSH operations: {e}")
-                return 1
-            finally:
-                ssh.close()
-
-        except Exception as e:
-            logger.error(f"Error managing SONiC device {hostname}: {e}")
-            return 1

osism/commands/redfish.py

@@ -0,0 +1,219 @@
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from cliff.command import Command
+from loguru import logger
+from tabulate import tabulate
+
+from osism.tasks.conductor import get_redfish_resources
+
+
+class List(Command):
+    def _normalize_column_name(self, column_name):
+        """Normalize column name to lowercase with underscores instead of spaces."""
+        if not column_name:
+            return column_name
+        return column_name.lower().replace(" ", "_")
+
+    def _get_column_mappings(self, resourcetype):
+        """Get column mappings for a specific resource type."""
+        if resourcetype == "EthernetInterfaces":
+            return {
+                "ID": "id",
+                "Name": "name",
+                "Description": "description",
+                "MAC Address": "mac_address",
+                "Permanent MAC Address": "permanent_mac_address",
+                "Speed (Mbps)": "speed_mbps",
+                "MTU Size": "mtu_size",
+                "Link Status": "link_status",
+                "Interface Enabled": "interface_enabled",
+            }
+        elif resourcetype == "NetworkAdapters":
+            return {
+                "ID": "id",
+                "Name": "name",
+                "Description": "description",
+                "Manufacturer": "manufacturer",
+                "Model": "model",
+                "Part Number": "part_number",
+                "Serial Number": "serial_number",
+                "Firmware Version": "firmware_version",
+            }
+        elif resourcetype == "NetworkDeviceFunctions":
+            return {
+                "ID": "id",
+                "Name": "name",
+                "Description": "description",
+                "Device Enabled": "device_enabled",
+                "Ethernet Enabled": "ethernet_enabled",
+                "MAC Address": "mac_address",
+                "Permanent MAC Address": "permanent_mac_address",
+                "Adapter ID": "adapter_id",
+                "Adapter Name": "adapter_name",
+            }
+        return None
+
+    def _get_filtered_columns(self, column_mappings, selected_columns=None):
+        """Get filtered column mappings based on selected columns."""
+        # If no columns specified, use all available columns
+        if not selected_columns:
+            return list(column_mappings.keys()), list(column_mappings.values())
+
+        # Normalize selected columns and filter
+        normalized_selected = [
+            self._normalize_column_name(col) for col in selected_columns
+        ]
+        headers = []
+        data_keys = []
+
+        for display_name, data_key in column_mappings.items():
+            normalized_display = self._normalize_column_name(display_name)
+            if normalized_display in normalized_selected:
+                headers.append(display_name)
+                data_keys.append(data_key)
+
+        # Check if any requested columns were not found
+        found_columns = [self._normalize_column_name(h) for h in headers]
+        for requested_col in normalized_selected:
+            if requested_col not in found_columns:
+                logger.warning(
+                    f"Column '{requested_col}' not found. Available columns: {list(column_mappings.keys())}"
+                )
+
+        return headers, data_keys
+
+    def _filter_json_data(self, data, data_keys):
+        """Filter JSON data to include only selected columns."""
+        if not data or not data_keys:
+            return data
+
+        filtered_data = []
+        for item in data:
+            filtered_item = {key: item.get(key) for key in data_keys}
+            filtered_data.append(filtered_item)
+
+        return filtered_data
+
+    def _filter_and_display_table(self, data, column_mappings, selected_columns=None):
+        """Generic method to filter columns and display table data."""
+        if not data:
+            return
+
+        headers, data_keys = self._get_filtered_columns(
+            column_mappings, selected_columns
+        )
+
+        if not headers:
+            print("No valid columns specified")
+            return
+
+        # Prepare table data
+        table_data = []
+        for item in data:
+            row = [item.get(key, "N/A") for key in data_keys]
+            table_data.append(row)
+
+        # Display the table
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+        print(f"\nTotal items: {len(data)}")
+
+    def get_parser(self, prog_name):
+        parser = super(List, self).get_parser(prog_name)
+        parser.add_argument(
+            "hostname",
+            type=str,
+            help="Hostname of the target system",
+        )
+        parser.add_argument(
+            "resourcetype",
+            type=str,
+            help="Resource type to process (e.g., EthernetInterfaces, NetworkAdapters, NetworkDeviceFunctions)",
+        )
+        parser.add_argument(
+            "--format",
+            type=str,
+            choices=["table", "json"],
+            default="table",
+            help="Output format (default: table)",
+        )
+        parser.add_argument(
+            "--column",
+            action="append",
+            help="Column to include in output (can be used multiple times)",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        hostname = parsed_args.hostname
+        resourcetype = parsed_args.resourcetype
+        output_format = parsed_args.format
+        columns = parsed_args.column
+        logger.info(
+            f"Redfish list command called with hostname: {hostname}, resourcetype: {resourcetype}, format: {output_format}"
+        )
+
+        # Use Celery task to get Redfish resources
+        task_result = get_redfish_resources.delay(hostname, resourcetype)
+        result = task_result.get()
+
+        if output_format == "json":
+            if result:
+                # Apply column filtering for JSON output if columns are specified
+                if columns:
+                    # Get column mappings for the resource type
+                    column_mappings = self._get_column_mappings(resourcetype)
+                    if column_mappings:
+                        _, data_keys = self._get_filtered_columns(
+                            column_mappings, columns
+                        )
+                        filtered_result = self._filter_json_data(result, data_keys)
+                        print(json.dumps(filtered_result, indent=2))
+                    else:
+                        print(json.dumps(result, indent=2))
+                else:
+                    print(json.dumps(result, indent=2))
+            else:
+                print("[]")
+        else:
+            if resourcetype == "EthernetInterfaces" and result:
+                self._display_ethernet_interfaces(result, columns)
+            elif resourcetype == "NetworkAdapters" and result:
+                self._display_network_adapters(result, columns)
+            elif resourcetype == "NetworkDeviceFunctions" and result:
+                self._display_network_device_functions(result, columns)
+            elif result:
+                logger.info(f"Retrieved resources: {result}")
+            else:
+                print(f"No {resourcetype} resources found for {hostname}")
+
+    def _display_ethernet_interfaces(self, interfaces, selected_columns=None):
+        """Display EthernetInterfaces in a formatted table."""
+        if not interfaces:
+            print("No EthernetInterfaces found")
+            return
+
+        column_mappings = self._get_column_mappings("EthernetInterfaces")
+        self._filter_and_display_table(interfaces, column_mappings, selected_columns)
+
+    def _display_network_adapters(self, adapters, selected_columns=None):
+        """Display NetworkAdapters in a formatted table."""
+        if not adapters:
+            print("No NetworkAdapters found")
+            return
+
+        column_mappings = self._get_column_mappings("NetworkAdapters")
+        self._filter_and_display_table(adapters, column_mappings, selected_columns)
+
+    def _display_network_device_functions(
+        self, device_functions, selected_columns=None
+    ):
+        """Display NetworkDeviceFunctions in a formatted table."""
+        if not device_functions:
+            print("No NetworkDeviceFunctions found")
+            return
+
+        column_mappings = self._get_column_mappings("NetworkDeviceFunctions")
+        self._filter_and_display_table(
+            device_functions, column_mappings, selected_columns
+        )