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

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/sonic/config_generator.py

@@ -201,6 +201,9 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
     # Add NTP server configuration (device-specific)
     _add_ntp_configuration(config, device)
 
+    # Add DNS server configuration (device-specific)
+    _add_dns_configuration(config, device)
+
     # Add VLAN configuration
     _add_vlan_configuration(config, vlan_info, netbox_interfaces, device)
 
@@ -694,18 +697,20 @@ def _determine_peer_type(local_device, connected_device, device_as_mapping=None)
         return "external"  # Default to external on error
 
 
-def _get_ntp_server_for_device(device):
-    """Get single NTP server IP for a SONiC device based on OOB connection to metalbox.
+def _get_metalbox_ip_for_device(device):
+    """Get Metalbox IP for a SONiC device based on OOB connection.
 
     Returns the IP address of the metalbox device interface that is connected to the
     OOB switch. If VLANs are used, returns the IP of the VLAN interface where the
     SONiC switch management interface (eth0) has access.
 
+    This IP is used for both NTP and DNS services.
+
     Args:
         device: SONiC device object
 
     Returns:
-        str: IP address of the NTP server or None if not found
+        str: IP address of the Metalbox or None if not found
     """
     try:
         # Get the OOB IP configuration for this SONiC device
@@ -726,7 +731,7 @@ def _get_ntp_server_for_device(device):
         metalbox_devices = utils.nb.dcim.devices.filter(role="metalbox")
 
         for metalbox in metalbox_devices:
-            logger.debug(f"Checking metalbox device {metalbox.name} for NTP server")
+            logger.debug(f"Checking metalbox device {metalbox.name} for services")
 
             # Get all interfaces on this metalbox
             interfaces = utils.nb.dcim.interfaces.filter(device_id=metalbox.id)
@@ -765,7 +770,7 @@ def _get_ntp_server_for_device(device):
                                     else "interface"
                                 )
                                 logger.info(
-                                    f"Found NTP server {ip_only} on metalbox {metalbox.name} "
+                                    f"Found Metalbox {ip_only} on {metalbox.name} "
                                     f"{interface_type} {interface.name} for SONiC device {device.name}"
                                 )
                                 return ip_only
@@ -773,11 +778,11 @@ def _get_ntp_server_for_device(device):
                             # Skip non-IPv4 addresses
                             continue
 
-        logger.warning(f"No suitable NTP server found for SONiC device {device.name}")
+        logger.warning(f"No suitable Metalbox found for SONiC device {device.name}")
         return None
 
     except Exception as e:
-        logger.warning(f"Could not determine NTP server for device {device.name}: {e}")
+        logger.warning(f"Could not determine Metalbox IP for device {device.name}: {e}")
         return None
 
 
@@ -846,19 +851,17 @@ def _add_ntp_configuration(config, device):
     metalbox device interface connected to the OOB switch.
     """
     try:
-        # Get the specific NTP server for this device
-        ntp_server_ip = _get_ntp_server_for_device(device)
+        # Get the Metalbox IP for this device
+        metalbox_ip = _get_metalbox_ip_for_device(device)
 
-        if ntp_server_ip:
+        if metalbox_ip:
             # Add single NTP server configuration
-            config["NTP_SERVER"][ntp_server_ip] = {
+            config["NTP_SERVER"][metalbox_ip] = {
                 "maxpoll": "10",
                 "minpoll": "6",
                 "prefer": "false",
             }
-            logger.info(
-                f"Added NTP server {ntp_server_ip} to SONiC device {device.name}"
-            )
+            logger.info(f"Added NTP server {metalbox_ip} to SONiC device {device.name}")
         else:
             logger.warning(f"No NTP server found for SONiC device {device.name}")
 
@@ -873,6 +876,27 @@ def clear_ntp_cache():
     logger.debug("Cleared NTP servers cache")
 
 
+def _add_dns_configuration(config, device):
+    """Add DNS_NAMESERVER configuration to device config.
+
+    Each SONiC switch gets exactly one DNS server - the IP address of the
+    metalbox device interface connected to the OOB switch.
+    """
+    try:
+        # Get the Metalbox IP for this device
+        metalbox_ip = _get_metalbox_ip_for_device(device)
+
+        if metalbox_ip:
+            # Add single DNS server configuration
+            config["DNS_NAMESERVER"][metalbox_ip] = {}
+            logger.info(f"Added DNS server {metalbox_ip} to SONiC device {device.name}")
+        else:
+            logger.warning(f"No DNS server found for SONiC device {device.name}")
+
+    except Exception as e:
+        logger.warning(f"Could not add DNS configuration to device {device.name}: {e}")
+
+
 def clear_all_caches():
     """Clear all caches in config_generator module."""
     clear_ntp_cache()

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/tasks/netbox.py

@@ -2,7 +2,6 @@
 
 from celery import Celery
 from loguru import logger
-from pottery import Redlock
 
 from osism import settings, utils
 from osism.tasks import Config, run_command
@@ -30,9 +29,8 @@ def run(self, action, arguments):
 def set_maintenance(self, device_name, state=True):
     """Set the maintenance state for a device in the NetBox."""
 
-    lock = Redlock(
+    lock = utils.create_redlock(
         key=f"lock_osism_tasks_netbox_set_maintenance_{device_name}",
-        masters={utils.redis},
         auto_release_time=60,
     )
     if lock.acquire(timeout=20):
@@ -59,9 +57,8 @@ def set_maintenance(self, device_name, state=True):
 def set_provision_state(self, device_name, state):
     """Set the provision state for a device in the NetBox."""
 
-    lock = Redlock(
+    lock = utils.create_redlock(
         key=f"lock_osism_tasks_netbox_set_provision_state_{device_name}",
-        masters={utils.redis},
         auto_release_time=60,
     )
     if lock.acquire(timeout=20):
@@ -89,9 +86,8 @@ def set_provision_state(self, device_name, state):
 def set_power_state(self, device_name, state):
     """Set the provision state for a device in the NetBox."""
 
-    lock = Redlock(
+    lock = utils.create_redlock(
         key=f"lock_osism_tasks_netbox_set_provision_state_{device_name}",
-        masters={utils.redis},
         auto_release_time=60,
     )
     if lock.acquire(timeout=20):

osism/tasks/reconciler.py

@@ -6,7 +6,6 @@ import subprocess
 
 from celery import Celery
 from loguru import logger
-from pottery import Redlock
 
 from osism import settings, utils
 from osism.tasks import Config
@@ -17,9 +16,8 @@ app.config_from_object(Config)
 
 @app.on_after_configure.connect
 def setup_periodic_tasks(sender, **kwargs):
-    lock = Redlock(
+    lock = utils.create_redlock(
         key="lock_osism_tasks_reconciler_setup_periodic_tasks",
-        masters={utils.redis},
     )
     if settings.INVENTORY_RECONCILER_SCHEDULE > 0 and lock.acquire(timeout=10):
         sender.add_periodic_task(
@@ -29,9 +27,8 @@ def setup_periodic_tasks(sender, **kwargs):
 
 @app.task(bind=True, name="osism.tasks.reconciler.run")
 def run(self, publish=True, flush_cache=False):
-    lock = Redlock(
+    lock = utils.create_redlock(
         key="lock_osism_tasks_reconciler_run",
-        masters={utils.redis},
         auto_release_time=60,
     )
 
@@ -64,9 +61,8 @@ def run(self, publish=True, flush_cache=False):
 
 @app.task(bind=True, name="osism.tasks.reconciler.run_on_change")
 def run_on_change(self):
-    lock = Redlock(
+    lock = utils.create_redlock(
         key="lock_osism_tasks_reconciler_run_on_change",
-        masters={utils.redis},
         auto_release_time=60,
     )