osism 0.20250627.0__py3-none-any.whl → 0.20250701.0__py3-none-any.whl

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
+        )

osism/commands/validate.py

@@ -5,7 +5,7 @@ import argparse
 from cliff.command import Command
 from loguru import logger
 
-from osism.core.enums import VALIDATE_PLAYBOOKS
+from osism.data.enums import VALIDATE_PLAYBOOKS
 from osism.tasks import ansible, ceph, kolla
 from osism import utils
 

osism/settings.py

@@ -54,3 +54,6 @@ SONIC_EXPORT_IDENTIFIER = os.getenv("SONIC_EXPORT_IDENTIFIER", "serial-number")
 NETBOX_SECONDARIES = (
     os.getenv("NETBOX_SECONDARIES", read_secret("NETBOX_SECONDARIES")) or "[]"
 )
+
+# Redfish connection timeout in seconds
+REDFISH_TIMEOUT = int(os.getenv("REDFISH_TIMEOUT", "20"))

osism/tasks/conductor/__init__.py

@@ -8,6 +8,7 @@ from loguru import logger
 from osism.tasks import Config
 from osism.tasks.conductor.config import get_configuration
 from osism.tasks.conductor.ironic import sync_ironic as _sync_ironic
+from osism.tasks.conductor.redfish import get_resources as _get_redfish_resources
 from osism.tasks.conductor.sonic import sync_sonic as _sync_sonic
 
 
@@ -52,9 +53,15 @@ def sync_sonic(self, device_name=None, show_diff=True):
     return _sync_sonic(device_name, self.request.id, show_diff)
 
 
+@app.task(bind=True, name="osism.tasks.conductor.get_redfish_resources")
+def get_redfish_resources(self, hostname, resource_type):
+    return _get_redfish_resources(hostname, resource_type)
+
+
 __all__ = [
     "app",
     "get_ironic_parameters",
+    "get_redfish_resources",
     "sync_netbox",
     "sync_ironic",
     "sync_sonic",

osism/tasks/conductor/config.py

@@ -1,22 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
 
-import uuid
-
 from loguru import logger
+import validators
 import yaml
 
 from osism.tasks import Config, openstack
 
 
-def is_uuid(value):
-    """Check if a string is a valid UUID."""
-    try:
-        uuid.UUID(value)
-        return True
-    except (ValueError, AttributeError):
-        return False
-
-
 def get_configuration():
     with open("/etc/conductor.yml") as fp:
         configuration = yaml.load(fp, Loader=yaml.SafeLoader)
@@ -39,54 +29,81 @@ def get_configuration():
                 image_source = configuration["ironic_parameters"]["instance_info"][
                     "image_source"
                 ]
-                if not is_uuid(image_source):
+                if not validators.uuid(image_source) and not validators.url(
+                    image_source
+                ):
                     result = openstack.image_get(image_source)
-                    configuration["ironic_parameters"]["instance_info"][
-                        "image_source"
-                    ] = result.id
+                    if result:
+                        configuration["ironic_parameters"]["instance_info"][
+                            "image_source"
+                        ] = result.id
+                    else:
+                        logger.warning(f"Could not resolve image ID for {image_source}")
 
         if "driver_info" in configuration["ironic_parameters"]:
             if "deploy_kernel" in configuration["ironic_parameters"]["driver_info"]:
                 deploy_kernel = configuration["ironic_parameters"]["driver_info"][
                     "deploy_kernel"
                 ]
-                if not is_uuid(deploy_kernel):
+                if not validators.uuid(deploy_kernel) and not validators.url(
+                    deploy_kernel
+                ):
                     result = openstack.image_get(deploy_kernel)
-                    configuration["ironic_parameters"]["driver_info"][
-                        "deploy_kernel"
-                    ] = result.id
+                    if result:
+                        configuration["ironic_parameters"]["driver_info"][
+                            "deploy_kernel"
+                        ] = result.id
+                    else:
+                        logger.warning(
+                            f"Could not resolve image ID for {deploy_kernel}"
+                        )
 
             if "deploy_ramdisk" in configuration["ironic_parameters"]["driver_info"]:
                 deploy_ramdisk = configuration["ironic_parameters"]["driver_info"][
                     "deploy_ramdisk"
                 ]
-                if not is_uuid(deploy_ramdisk):
+                if not validators.uuid(deploy_ramdisk) and not validators.url(
+                    deploy_ramdisk
+                ):
                     result = openstack.image_get(deploy_ramdisk)
-                    configuration["ironic_parameters"]["driver_info"][
-                        "deploy_ramdisk"
-                    ] = result.id
+                    if result:
+                        configuration["ironic_parameters"]["driver_info"][
+                            "deploy_ramdisk"
+                        ] = result.id
+                    else:
+                        logger.warning(
+                            f"Could not resolve image ID for {deploy_ramdisk}"
+                        )
 
             if "cleaning_network" in configuration["ironic_parameters"]["driver_info"]:
-                result = openstack.network_get(
+                cleaning_network = configuration["ironic_parameters"]["driver_info"][
+                    "cleaning_network"
+                ]
+                result = openstack.network_get(cleaning_network)
+                if result:
                     configuration["ironic_parameters"]["driver_info"][
                         "cleaning_network"
-                    ]
-                )
-                configuration["ironic_parameters"]["driver_info"][
-                    "cleaning_network"
-                ] = result.id
+                    ] = result.id
+                else:
+                    logger.warning(
+                        f"Could not resolve network ID for {cleaning_network}"
+                    )
 
             if (
                 "provisioning_network"
                 in configuration["ironic_parameters"]["driver_info"]
             ):
-                result = openstack.network_get(
+                provisioning_network = configuration["ironic_parameters"][
+                    "driver_info"
+                ]["provisioning_network"]
+                result = openstack.network_get(provisioning_network)
+                if result:
                     configuration["ironic_parameters"]["driver_info"][
                         "provisioning_network"
-                    ]
-                )
-                configuration["ironic_parameters"]["driver_info"][
-                    "provisioning_network"
-                ] = result.id
+                    ] = result.id
+                else:
+                    logger.warning(
+                        f"Could not resolve network ID for {provisioning_network}"
+                    )
 
         return configuration

osism/tasks/conductor/ironic.py

@@ -34,6 +34,100 @@ driver_params = {
 }
 
 
+def _prepare_node_attributes(device, get_ironic_parameters):
+    node_attributes = get_ironic_parameters()
+    if (
+        "ironic_parameters" in device.custom_fields
+        and device.custom_fields["ironic_parameters"]
+    ):
+        deep_merge(node_attributes, device.custom_fields["ironic_parameters"])
+
+    vault = get_vault()
+    deep_decrypt(node_attributes, vault)
+
+    node_secrets = device.custom_fields.get("secrets", {})
+    if node_secrets is None:
+        node_secrets = {}
+    deep_decrypt(node_secrets, vault)
+
+    if (
+        "driver" in node_attributes
+        and node_attributes["driver"] in driver_params.keys()
+    ):
+        if "driver_info" in node_attributes:
+            unused_drivers = [
+                driver
+                for driver in driver_params.keys()
+                if driver != node_attributes["driver"]
+            ]
+            for key in list(node_attributes["driver_info"].keys()):
+                for driver in unused_drivers:
+                    if key.startswith(driver + "_"):
+                        node_attributes["driver_info"].pop(key, None)
+
+            username_key = driver_params[node_attributes["driver"]]["username"]
+            if username_key in node_attributes["driver_info"]:
+                node_attributes["driver_info"][username_key] = (
+                    jinja2.Environment(loader=jinja2.BaseLoader())
+                    .from_string(node_attributes["driver_info"][username_key])
+                    .render(
+                        remote_board_username=str(
+                            node_secrets.get("remote_board_username", "admin")
+                        )
+                    )
+                )
+
+            password_key = driver_params[node_attributes["driver"]]["password"]
+            if password_key in node_attributes["driver_info"]:
+                node_attributes["driver_info"][password_key] = (
+                    jinja2.Environment(loader=jinja2.BaseLoader())
+                    .from_string(node_attributes["driver_info"][password_key])
+                    .render(
+                        remote_board_password=str(
+                            node_secrets.get("remote_board_password", "password")
+                        )
+                    )
+                )
+
+            address_key = driver_params[node_attributes["driver"]]["address"]
+            if address_key in node_attributes["driver_info"]:
+                oob_ip_result = get_device_oob_ip(device)
+                if oob_ip_result:
+                    oob_ip, _ = oob_ip_result
+                    node_attributes["driver_info"][address_key] = (
+                        jinja2.Environment(loader=jinja2.BaseLoader())
+                        .from_string(node_attributes["driver_info"][address_key])
+                        .render(remote_board_address=oob_ip)
+                    )
+    node_attributes.update({"resource_class": device.name})
+    if "extra" not in node_attributes:
+        node_attributes["extra"] = {}
+    if "instance_info" in node_attributes and node_attributes["instance_info"]:
+        node_attributes["extra"].update(
+            {"instance_info": json.dumps(node_attributes["instance_info"])}
+        )
+    if (
+        "netplan_parameters" in device.custom_fields
+        and device.custom_fields["netplan_parameters"]
+    ):
+        node_attributes["extra"].update(
+            {
+                "netplan_parameters": json.dumps(
+                    device.custom_fields["netplan_parameters"]
+                )
+            }
+        )
+    if (
+        "frr_parameters" in device.custom_fields
+        and device.custom_fields["frr_parameters"]
+    ):
+        node_attributes["extra"].update(
+            {"frr_parameters": json.dumps(device.custom_fields["frr_parameters"])}
+        )
+
+    return node_attributes
+
+
 def sync_ironic(request_id, get_ironic_parameters, force_update=False):
     osism_utils.push_task_output(
         request_id,
@@ -79,105 +173,7 @@ def sync_ironic(request_id, get_ironic_parameters, force_update=False):
 
         node_interfaces = list(netbox.get_interfaces_by_device(device.name))
 
-        node_attributes = get_ironic_parameters()
-        if (
-            "ironic_parameters" in device.custom_fields
-            and device.custom_fields["ironic_parameters"]
-        ):
-            # NOTE: Update node attributes with overrides from NetBox device
-            deep_merge(node_attributes, device.custom_fields["ironic_parameters"])
-
-        # NOTE: Decrypt ansible vaulted secrets
-        vault = get_vault()
-        deep_decrypt(node_attributes, vault)
-
-        node_secrets = device.custom_fields.get("secrets", {})
-        if node_secrets is None:
-            node_secrets = {}
-        deep_decrypt(node_secrets, vault)
-
-        if (
-            "driver" in node_attributes
-            and node_attributes["driver"] in driver_params.keys()
-        ):
-            if "driver_info" in node_attributes:
-                # NOTE: Remove all fields belonging to a different driver
-                unused_drivers = [
-                    driver
-                    for driver in driver_params.keys()
-                    if driver != node_attributes["driver"]
-                ]
-                for key in list(node_attributes["driver_info"].keys()):
-                    for driver in unused_drivers:
-                        if key.startswith(driver + "_"):
-                            node_attributes["driver_info"].pop(key, None)
-
-                # NOTE: Render driver username field
-                username_key = driver_params[node_attributes["driver"]]["username"]
-                if username_key in node_attributes["driver_info"]:
-                    node_attributes["driver_info"][username_key] = (
-                        jinja2.Environment(loader=jinja2.BaseLoader())
-                        .from_string(node_attributes["driver_info"][username_key])
-                        .render(
-                            remote_board_username=str(
-                                node_secrets.get("remote_board_username", "admin")
-                            )
-                        )
-                    )
-
-                # NOTE: Render driver password field
-                password_key = driver_params[node_attributes["driver"]]["password"]
-                if password_key in node_attributes["driver_info"]:
-                    node_attributes["driver_info"][password_key] = (
-                        jinja2.Environment(loader=jinja2.BaseLoader())
-                        .from_string(node_attributes["driver_info"][password_key])
-                        .render(
-                            remote_board_password=str(
-                                node_secrets.get("remote_board_password", "password")
-                            )
-                        )
-                    )
-
-                # NOTE: Render driver address field
-                address_key = driver_params[node_attributes["driver"]]["address"]
-                if address_key in node_attributes["driver_info"]:
-                    oob_ip_result = get_device_oob_ip(device)
-                    if oob_ip_result:
-                        oob_ip, _ = (
-                            oob_ip_result  # Extract IP address, ignore prefix length
-                        )
-                        node_attributes["driver_info"][address_key] = (
-                            jinja2.Environment(loader=jinja2.BaseLoader())
-                            .from_string(node_attributes["driver_info"][address_key])
-                            .render(remote_board_address=oob_ip)
-                        )
-        node_attributes.update({"resource_class": device.name})
-        if "extra" not in node_attributes:
-            node_attributes["extra"] = {}
-        # NOTE: Copy instance_info into extra field. because ironic removes it on undeployment. This way it may be readded on undeploy without querying the netbox again
-        if "instance_info" in node_attributes and node_attributes["instance_info"]:
-            node_attributes["extra"].update(
-                {"instance_info": json.dumps(node_attributes["instance_info"])}
-            )
-        # NOTE: Write metadata used for provisioning into 'extra' field, so that it is available during node deploy without querying the netbox again
-        if (
-            "netplan_parameters" in device.custom_fields
-            and device.custom_fields["netplan_parameters"]
-        ):
-            node_attributes["extra"].update(
-                {
-                    "netplan_parameters": json.dumps(
-                        device.custom_fields["netplan_parameters"]
-                    )
-                }
-            )
-        if (
-            "frr_parameters" in device.custom_fields
-            and device.custom_fields["frr_parameters"]
-        ):
-            node_attributes["extra"].update(
-                {"frr_parameters": json.dumps(device.custom_fields["frr_parameters"])}
-            )
+        node_attributes = _prepare_node_attributes(device, get_ironic_parameters)
         ports_attributes = [
             dict(address=interface.mac_address)
             for interface in node_interfaces