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

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/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/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

osism/tasks/conductor/redfish.py

@@ -0,0 +1,300 @@
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from loguru import logger
+from osism.tasks.conductor.utils import get_redfish_connection
+
+
+def _normalize_redfish_data(data):
+    """
+    Convert Redfish data values to strings and clean up None values.
+
+    Args:
+        data (dict): Dictionary with Redfish resource data
+
+    Returns:
+        dict: Dictionary with normalized string values, None values removed
+    """
+    normalized_data = {}
+
+    for key, value in data.items():
+        if value is not None:
+            if isinstance(value, (dict, list)):
+                # Convert complex objects to JSON strings
+                normalized_data[key] = json.dumps(value)
+            elif isinstance(value, bool):
+                # Convert booleans to lowercase strings
+                normalized_data[key] = str(value).lower()
+            elif not isinstance(value, str):
+                # Convert numbers and other types to strings
+                normalized_data[key] = str(value)
+            else:
+                # Keep strings as-is
+                normalized_data[key] = value
+
+    return normalized_data
+
+
+def get_resources(hostname, resource_type):
+    """
+    Get Redfish resources for a specific hostname and resource type.
+
+    Args:
+        hostname (str): The hostname of the target system
+        resource_type (str): The type of resource to retrieve (e.g., EthernetInterfaces)
+
+    Returns:
+        list: Retrieved Redfish resources or empty list if failed
+    """
+    logger.info(
+        f"Getting Redfish resources for hostname: {hostname}, resource_type: {resource_type}"
+    )
+
+    if resource_type == "EthernetInterfaces":
+        return _get_ethernet_interfaces(hostname)
+    elif resource_type == "NetworkAdapters":
+        return _get_network_adapters(hostname)
+    elif resource_type == "NetworkDeviceFunctions":
+        return _get_network_device_functions(hostname)
+
+    logger.warning(f"Resource type {resource_type} not supported yet")
+    return []
+
+
+def _get_ethernet_interfaces(hostname):
+    """
+    Get all EthernetInterfaces from a Redfish-enabled system.
+
+    Args:
+        hostname (str): The hostname of the target system
+
+    Returns:
+        list: List of EthernetInterface dictionaries
+    """
+    try:
+        # Get Redfish connection using the utility function
+        redfish_conn = get_redfish_connection(hostname, ignore_ssl_errors=True)
+
+        if not redfish_conn:
+            logger.error(f"Could not establish Redfish connection to {hostname}")
+            return []
+
+        ethernet_interfaces = []
+
+        # Navigate through the Redfish service to find EthernetInterfaces
+        # Structure: /redfish/v1/Systems/{system_id}/EthernetInterfaces
+        for system in redfish_conn.get_system_collection().get_members():
+            logger.debug(f"Processing system: {system.identity}")
+
+            # Check if the system has EthernetInterfaces
+            if hasattr(system, "ethernet_interfaces") and system.ethernet_interfaces:
+                for interface in system.ethernet_interfaces.get_members():
+                    try:
+                        # Extract relevant information from each EthernetInterface
+                        interface_data = {
+                            "id": interface.identity,
+                            "name": getattr(interface, "name", None),
+                            "description": getattr(interface, "description", None),
+                            "mac_address": getattr(interface, "mac_address", None),
+                            "permanent_mac_address": getattr(
+                                interface, "permanent_mac_address", None
+                            ),
+                            "speed_mbps": getattr(interface, "speed_mbps", None),
+                            "mtu_size": getattr(interface, "mtu_size", None),
+                            "link_status": getattr(interface, "link_status", None),
+                            "interface_enabled": getattr(
+                                interface, "interface_enabled", None
+                            ),
+                        }
+
+                        # Normalize data values to strings and clean up None values
+                        interface_data = _normalize_redfish_data(interface_data)
+
+                        ethernet_interfaces.append(interface_data)
+                        logger.debug(
+                            f"Found EthernetInterface: {interface_data.get('name', interface_data.get('id'))}"
+                        )
+
+                    except Exception as exc:
+                        logger.warning(
+                            f"Error processing EthernetInterface {interface.identity}: {exc}"
+                        )
+                        continue
+
+        logger.info(
+            f"Retrieved {len(ethernet_interfaces)} EthernetInterfaces from {hostname}"
+        )
+        return ethernet_interfaces
+
+    except Exception as exc:
+        logger.error(f"Error retrieving EthernetInterfaces from {hostname}: {exc}")
+        return []
+
+
+def _get_network_adapters(hostname):
+    """
+    Get all NetworkAdapters from a Redfish-enabled system.
+
+    Args:
+        hostname (str): The hostname of the target system
+
+    Returns:
+        list: List of NetworkAdapter dictionaries
+    """
+    try:
+        # Get Redfish connection using the utility function
+        redfish_conn = get_redfish_connection(hostname, ignore_ssl_errors=True)
+
+        if not redfish_conn:
+            logger.error(f"Could not establish Redfish connection to {hostname}")
+            return []
+
+        network_adapters = []
+
+        # Navigate through the Redfish service to find NetworkAdapters
+        # Structure: /redfish/v1/Chassis/{chassis_id}/NetworkAdapters
+        for chassis in redfish_conn.get_chassis_collection().get_members():
+            logger.debug(f"Processing chassis: {chassis.identity}")
+
+            # Check if the chassis has NetworkAdapters
+            if hasattr(chassis, "network_adapters") and chassis.network_adapters:
+                for adapter in chassis.network_adapters.get_members():
+                    try:
+                        # Extract relevant information from each NetworkAdapter
+                        adapter_data = {
+                            "id": adapter.identity,
+                            "name": getattr(adapter, "name", None),
+                            "description": getattr(adapter, "description", None),
+                            "manufacturer": getattr(adapter, "manufacturer", None),
+                            "model": getattr(adapter, "model", None),
+                            "part_number": getattr(adapter, "part_number", None),
+                            "serial_number": getattr(adapter, "serial_number", None),
+                            "firmware_version": getattr(
+                                adapter, "firmware_version", None
+                            ),
+                        }
+
+                        # Normalize data values to strings and clean up None values
+                        adapter_data = _normalize_redfish_data(adapter_data)
+
+                        network_adapters.append(adapter_data)
+                        logger.debug(
+                            f"Found NetworkAdapter: {adapter_data.get('name', adapter_data.get('id'))}"
+                        )
+
+                    except Exception as exc:
+                        logger.warning(
+                            f"Error processing NetworkAdapter {adapter.identity}: {exc}"
+                        )
+                        continue
+
+        logger.info(
+            f"Retrieved {len(network_adapters)} NetworkAdapters from {hostname}"
+        )
+        return network_adapters
+
+    except Exception as exc:
+        logger.error(f"Error retrieving NetworkAdapters from {hostname}: {exc}")
+        return []
+
+
+def _get_network_device_functions(hostname):
+    """
+    Get all NetworkDeviceFunctions from a Redfish-enabled system.
+
+    Args:
+        hostname (str): The hostname of the target system
+
+    Returns:
+        list: List of NetworkDeviceFunction dictionaries with MAC addresses
+    """
+    try:
+        # Get Redfish connection using the utility function
+        redfish_conn = get_redfish_connection(hostname, ignore_ssl_errors=True)
+
+        if not redfish_conn:
+            logger.error(f"Could not establish Redfish connection to {hostname}")
+            return []
+
+        network_device_functions = []
+
+        # Navigate through the Redfish service to find NetworkDeviceFunctions
+        # Structure: /redfish/v1/Chassis/{chassis_id}/NetworkAdapters/{adapter_id}/NetworkDeviceFunctions
+        for chassis in redfish_conn.get_chassis_collection().get_members():
+            logger.debug(f"Processing chassis: {chassis.identity}")
+
+            # Check if the chassis has NetworkAdapters
+            if hasattr(chassis, "network_adapters") and chassis.network_adapters:
+                for adapter in chassis.network_adapters.get_members():
+                    logger.debug(f"Processing NetworkAdapter: {adapter.identity}")
+
+                    try:
+                        for (
+                            device_func
+                        ) in adapter.network_device_functions.get_members():
+                            try:
+                                # Extract MAC address from Ethernet configuration
+                                mac_address = None
+                                permanent_mac_address = None
+
+                                # Try to get MAC from ethernet configuration
+                                if (
+                                    hasattr(device_func, "ethernet")
+                                    and device_func.ethernet
+                                ):
+                                    ethernet_config = device_func.ethernet
+                                    mac_address = getattr(
+                                        ethernet_config, "mac_address", None
+                                    )
+                                    permanent_mac_address = getattr(
+                                        ethernet_config, "permanent_mac_address", None
+                                    )
+
+                                # Extract relevant information from each NetworkDeviceFunction
+                                device_func_data = {
+                                    "id": device_func.identity,
+                                    "name": getattr(device_func, "name", None),
+                                    "description": getattr(
+                                        device_func, "description", None
+                                    ),
+                                    "device_enabled": getattr(
+                                        device_func, "device_enabled", None
+                                    ),
+                                    "ethernet_enabled": getattr(
+                                        device_func, "ethernet_enabled", None
+                                    ),
+                                    "mac_address": mac_address,
+                                    "permanent_mac_address": permanent_mac_address,
+                                    "adapter_id": adapter.identity,
+                                    "adapter_name": getattr(adapter, "name", None),
+                                }
+
+                                # Normalize data values to strings and clean up None values
+                                device_func_data = _normalize_redfish_data(
+                                    device_func_data
+                                )
+
+                                network_device_functions.append(device_func_data)
+                                logger.debug(
+                                    f"Found NetworkDeviceFunction: {device_func_data.get('name', device_func_data.get('id'))}"
+                                )
+
+                            except Exception as exc:
+                                logger.warning(
+                                    f"Error processing NetworkDeviceFunction {device_func.identity}: {exc}"
+                                )
+                                continue
+                    except Exception as exc:
+                        logger.warning(
+                            f"Error processing NetworkAdapter {adapter.identity}: {exc}"
+                        )
+                        continue
+
+        logger.info(
+            f"Retrieved {len(network_device_functions)} NetworkDeviceFunctions from {hostname}"
+        )
+        return network_device_functions
+
+    except Exception as exc:
+        logger.error(f"Error retrieving NetworkDeviceFunctions from {hostname}: {exc}")
+        return []

osism/tasks/conductor/utils.py

@@ -5,6 +5,8 @@ from ansible.parsing.vault import VaultLib, VaultSecret
 from loguru import logger
 
 from osism import utils
+import sushy
+import urllib3
 
 
 def deep_compare(a, b, updates):
@@ -77,3 +79,149 @@ def get_vault():
         logger.error("Unable to get vault secret. Dropping encrypted entries")
         vault = VaultLib()
     return vault
+
+
+def get_redfish_connection(
+    hostname, username=None, password=None, ignore_ssl_errors=True, timeout=None
+):
+    """Create a Redfish connection to the specified hostname."""
+    from osism import settings
+    from osism.tasks import openstack
+
+    if not hostname:
+        return None
+
+    # Use configurable timeout if not provided
+    if timeout is None:
+        timeout = settings.REDFISH_TIMEOUT
+
+    # Get Redfish address from Ironic driver_info
+    base_url = f"https://{hostname}"
+    device = None
+
+    # Try to find NetBox device first for conductor configuration fallback
+    if utils.nb:
+        try:
+            # First try to find device by name
+            device = utils.nb.dcim.devices.get(name=hostname)
+
+            # If not found by name, try by inventory_hostname custom field
+            if not device:
+                devices = utils.nb.dcim.devices.filter(cf_inventory_hostname=hostname)
+                if devices:
+                    device = devices[0]
+        except Exception as exc:
+            logger.warning(f"Could not resolve hostname {hostname} via NetBox: {exc}")
+
+    try:
+        ironic_node = openstack.baremetal_node_show(hostname, ignore_missing=True)
+        if ironic_node and "driver_info" in ironic_node:
+            driver_info = ironic_node["driver_info"]
+            # Use redfish_address from driver_info if available (contains full URL)
+            if "redfish_address" in driver_info:
+                base_url = driver_info["redfish_address"]
+                logger.info(f"Using Ironic redfish_address {base_url} for {hostname}")
+        else:
+            # Fallback to conductor configuration if Ironic driver_info not available
+            conductor_address = _get_conductor_redfish_address(device)
+            if conductor_address:
+                base_url = conductor_address
+                logger.info(
+                    f"Using conductor redfish_address {base_url} for {hostname}"
+                )
+    except Exception as exc:
+        logger.warning(f"Could not get Ironic node for {hostname}: {exc}")
+        # Fallback to conductor configuration on Ironic error
+        conductor_address = _get_conductor_redfish_address(device)
+        if conductor_address:
+            base_url = conductor_address
+            logger.info(f"Using conductor redfish_address {base_url} for {hostname}")
+
+    # Get credentials from conductor configuration if not provided
+    if not username or not password:
+        conductor_username, conductor_password = _get_conductor_redfish_credentials(
+            device
+        )
+        if not username:
+            username = conductor_username
+        if not password:
+            password = conductor_password
+
+    auth = sushy.auth.SessionOrBasicAuth(username=username, password=password)
+
+    try:
+        if ignore_ssl_errors:
+            urllib3.disable_warnings()
+            conn = sushy.Sushy(base_url, auth=auth, verify=False)
+        else:
+            conn = sushy.Sushy(base_url, auth=auth)
+
+        return conn
+    except Exception as exc:
+        logger.error(
+            f"Unable to connect to Redfish API at {base_url} with timeout {timeout}s: {exc}"
+        )
+        return None
+
+
+def _get_conductor_redfish_credentials(device):
+    """Get Redfish credentials from conductor configuration and device secrets."""
+    from osism.tasks.conductor.config import get_configuration
+    from osism.tasks.conductor.ironic import _prepare_node_attributes
+
+    try:
+        if not device:
+            return None, None
+
+        # Use _prepare_node_attributes to get processed node attributes
+        def get_ironic_parameters():
+            configuration = get_configuration()
+            return configuration.get("ironic_parameters", {})
+
+        node_attributes = _prepare_node_attributes(device, get_ironic_parameters)
+
+        # Extract Redfish credentials if available
+        if (
+            "driver_info" in node_attributes
+            and node_attributes.get("driver") == "redfish"
+        ):
+            driver_info = node_attributes["driver_info"]
+            username = driver_info.get("redfish_username")
+            password = driver_info.get("redfish_password")
+            return username, password
+
+    except Exception as exc:
+        logger.warning(f"Could not get conductor Redfish credentials: {exc}")
+
+    return None, None
+
+
+def _get_conductor_redfish_address(device):
+    """Get Redfish address from conductor configuration and device OOB IP."""
+    from osism.tasks.conductor.config import get_configuration
+    from osism.tasks.conductor.ironic import _prepare_node_attributes
+
+    try:
+        if not device:
+            return None
+
+        # Use _prepare_node_attributes to get processed node attributes
+        def get_ironic_parameters():
+            configuration = get_configuration()
+            return configuration.get("ironic_parameters", {})
+
+        node_attributes = _prepare_node_attributes(device, get_ironic_parameters)
+
+        # Extract Redfish address if available
+        if (
+            "driver_info" in node_attributes
+            and node_attributes.get("driver") == "redfish"
+        ):
+            driver_info = node_attributes["driver_info"]
+            address = driver_info.get("redfish_address")
+            return address
+
+    except Exception as exc:
+        logger.warning(f"Could not get conductor Redfish address: {exc}")
+
+    return None

{osism-0.20250628.0.dist-info → osism-0.20250701.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osism
-Version: 0.20250628.0
+Version: 0.20250701.0
 Summary: OSISM manager interface
 Home-page: https://github.com/osism/python-osism
 Author: OSISM GmbH
@@ -54,6 +54,7 @@ Requires-Dist: sushy==5.6.0
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: transitions==0.9.2
 Requires-Dist: uvicorn[standard]==0.35.0
+Requires-Dist: validators==0.35.0
 Requires-Dist: watchdog==6.0.0
 Provides-Extra: ansible
 Requires-Dist: ansible-runner==2.4.1; extra == "ansible"

{osism-0.20250628.0.dist-info → osism-0.20250701.0.dist-info}/RECORD

@@ -2,10 +2,10 @@ osism/__init__.py,sha256=1UiNTBus0V0f2AbZQzAtVtu6zkfCCrw0OTq--NwFAqY,341
 osism/__main__.py,sha256=ILe4gu61xEISiBsxanqTQIdSkV-YhpZXTRlguCYyssk,141
 osism/api.py,sha256=3kEfPJtPwuWD8luDNnEFRx3nEsUY5AeWnmjd4A5ii-A,11079
 osism/main.py,sha256=Dt2-9sLXcS-Ny4DAz7hrha-KRc7zd7BFUTRdfs_X8z4,893
-osism/settings.py,sha256=bebPBT6Hd1-KhJfwZdFR-s8eMwV4B1IFr-WrQBkOrWw,1786
+osism/settings.py,sha256=IUbUo8kru8TeiMAnnil5oHwd8SqbkPCY401dVONMygo,1885
 osism/commands/__init__.py,sha256=Ag4wX_DCgXRdoLn6t069jqb3DdRylsX2nyYkiyCx4uk,456
 osism/commands/apply.py,sha256=GWUccZAXlgkPYqylrCmdWcj8FCkDsPEipIIG937MeII,16833
-osism/commands/baremetal.py,sha256=w1LyZDms-DtULsF_76JsauOYHc2tcvoMRP6F9dYby9E,10688
+osism/commands/baremetal.py,sha256=yxCb0UwBfERinoGvlD9bvsGPEdDcHhq48Mn6u5b2aM8,12037
 osism/commands/compose.py,sha256=iqzG7mS9E1VWaLNN6yQowjOqiHn3BMdj-yfXb3Dc4Ok,1200
 osism/commands/compute.py,sha256=cgqXWJa5wAvn-7e3FWCgX6hie_aK0yrKRkcNzjLXwDY,25799
 osism/commands/configuration.py,sha256=sPe8b0dVKFRbr30xoeVdAnHbGwCwgUh0xa_Vzv5pSQQ,954
@@ -17,6 +17,7 @@ osism/commands/manage.py,sha256=uzfmt3R0PJ4HxUw_V945pN0FbKb3zhyiBuD9br1ORYE,2314
 osism/commands/netbox.py,sha256=e65P0kWrjTLw2T9HZthxjDTIRa-KAHgSSJAlvVef7n4,7345
 osism/commands/noset.py,sha256=7zDFuFMyNpo7DUOKcNiYV8nodtdMOYFp5LDPcuJhlZ8,1481
 osism/commands/reconciler.py,sha256=ubQfX8j13s3NuMKnT0Lt6O-szf7Z1V02AfsMQFHmO74,2209
+osism/commands/redfish.py,sha256=oBfxd5UBX4ED8XulEuIYziIYQqTvUKpKfcdGyg_AoiI,8431
 osism/commands/server.py,sha256=avmoOv5rjOi-fN2A-27cPwOtiy2Q2j6UFtCh3QrfWAI,7512
 osism/commands/service.py,sha256=A1lgAlGeCJpbFFqF55DRWPcCirIgpU0dzjzVLZ0mz3k,2649
 osism/commands/set.py,sha256=xLBi2DzbVQo2jb3-cOIE9In5UB3vFxquQJkDN-EsfhM,1425
@@ -42,11 +43,12 @@ osism/tasks/kubernetes.py,sha256=VzXq_VrYU_CLm4cOruqnE3Kq2ydfO9glZ3p0bp3OYoc,625
 osism/tasks/netbox.py,sha256=g0gL5QImiRTHqixRxze7LfNqPth7cXqLzVWQDUJLDjE,5928
 osism/tasks/openstack.py,sha256=g15tCll5vP1pC6ysxRCTZxplsdGmXbxaCH3k1Qdv5Xg,6367
 osism/tasks/reconciler.py,sha256=phbSV6urILqq9mHGMYDFwSfx8bLZmldwgEi8sMWs8RA,2040
-osism/tasks/conductor/__init__.py,sha256=eBkisjRj0YRT0AArvuvpIHGNEqEijsNvR_55BuVX62I,1600
-osism/tasks/conductor/config.py,sha256=tvfuYNgvw0F_ZbvrjqnyHfrj3vF6z0zhsRtGNu-Lgvo,3410
-osism/tasks/conductor/ironic.py,sha256=VT8JyYNh4IDWJ8QTIo46IokILKpGhINfLHjQvwz4FSU,16337
+osism/tasks/conductor/__init__.py,sha256=HW8CXpZOQ6aNgLZ3Ck08YcfQfueoA0ce35Kolh0rWww,1903
+osism/tasks/conductor/config.py,sha256=tMI0dtEFSWxfueRZdvocpbEq0sIN_PnXG08CuATkPz4,4489
+osism/tasks/conductor/ironic.py,sha256=Gx9LuWNMIMae4a3cVFKsTR4Hm_sr4jLf-JO9QBPSYcg,15402
 osism/tasks/conductor/netbox.py,sha256=5Nc7wrriDOtSuru1KDLt9QpA54vC7tXDPB2J0JP9GKo,11393
-osism/tasks/conductor/utils.py,sha256=-a0-pRuhV4Fjj0SgdgBqtRJtAdGdqck5pzfi6NYBApU,2338
+osism/tasks/conductor/redfish.py,sha256=hOOS-_l3Qmo_6vLsgjZmJwTxLTf029hhFRVkU0TMLL0,12723
+osism/tasks/conductor/utils.py,sha256=ZSbQumQr-uL-B9XOwbsscLIX7czJHu6Mq0t_poRpMsw,7769
 osism/tasks/conductor/sonic/__init__.py,sha256=oxTTl_MGK4iWK9uNDRNlULtGrDGCQHrlJZ04weh_Lh8,777
 osism/tasks/conductor/sonic/bgp.py,sha256=PC6gGI5bCj2PCXcNGyMV9-EdlJWDsYaodzxigmYSZvw,3088
 osism/tasks/conductor/sonic/cache.py,sha256=Asv2k3nLJejuq7iB0a_LyK8dEmJzypP9v3OHkNY3GwI,3438
@@ -58,11 +60,11 @@ osism/tasks/conductor/sonic/exporter.py,sha256=25L1vbi84ZQD0xNHNTWk-anTz5QRkGJsk
 osism/tasks/conductor/sonic/interface.py,sha256=318wOwXYSSMKTPP2WSZIps-JvIkCQ2gYdQs9ZYHXwwg,38957
 osism/tasks/conductor/sonic/sync.py,sha256=fpgsQVwq6Hb7eeDHhLkAqx5BkaK3Ce_m_WvmWEsJyOo,9182
 osism/utils/__init__.py,sha256=gN5VtLJfrvyn6_snuTte7YR-vDygkpbORopIV8qSEsA,6064
-osism-0.20250628.0.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
-osism-0.20250628.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-osism-0.20250628.0.dist-info/METADATA,sha256=rcVQq1RFwIJWgeRM4C6m33wkVLBrIWRr6uxb32HlP14,2904
-osism-0.20250628.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-osism-0.20250628.0.dist-info/entry_points.txt,sha256=eRq0DXdl4z2DdmPta6dqpzMe1M0DaUCNw9i4Jgdfhf0,3426
-osism-0.20250628.0.dist-info/pbr.json,sha256=NkG2tM3T6XeLebmfw4oRVNN2ALTn2QIvqsXacP_lLJU,47
-osism-0.20250628.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
-osism-0.20250628.0.dist-info/RECORD,,
+osism-0.20250701.0.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
+osism-0.20250701.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+osism-0.20250701.0.dist-info/METADATA,sha256=3Wd0oo4ezSU0A8zyKit87P9kOS1UANr07qNf_H5Y_QI,2938
+osism-0.20250701.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osism-0.20250701.0.dist-info/entry_points.txt,sha256=xpOV8qyAEuJ6-jrVDnVUUcTCyfBQQ_EOoj5ImcynClM,3476
+osism-0.20250701.0.dist-info/pbr.json,sha256=oc9bmpZsjLQNk1EI_gOw4MlbegkQGf47icU8U5FB0iY,47
+osism-0.20250701.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
+osism-0.20250701.0.dist-info/RECORD,,

{osism-0.20250628.0.dist-info → osism-0.20250701.0.dist-info}/entry_points.txt

@@ -43,6 +43,7 @@ manage image clusterapi = osism.commands.manage:ImageClusterapi
 manage image octavia = osism.commands.manage:ImageOctavia
 manage images = osism.commands.manage:Images
 manage netbox = osism.commands.netbox:Manage
+manage redfish list = osism.commands.redfish:List
 manage server list = osism.commands.server:ServerList
 manage server migrate = osism.commands.server:ServerMigrate
 manage sonic = osism.commands.manage:Sonic

osism-0.20250701.0.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "87129c8", "is_release": false}

osism-0.20250628.0.dist-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "f3fe7d7", "is_release": false}