osism 0.20250804.0__py3-none-any.whl → 0.20250823.0__py3-none-any.whl

osism/api.py

@@ -10,7 +10,7 @@ from fastapi import FastAPI, Header, Request, Response, HTTPException, status
 from pydantic import BaseModel, Field
 from starlette.middleware.cors import CORSMiddleware
 
-from osism.tasks import reconciler
+from osism.tasks import reconciler, openstack
 from osism import utils
 from osism.services.listener import BaremetalEvents
 
@@ -109,6 +109,35 @@ class DeviceSearchResult(BaseModel):
     device: Optional[str] = Field(None, description="Device name if found")
 
 
+class BaremetalNode(BaseModel):
+    uuid: str = Field(..., description="Unique identifier of the node")
+    name: Optional[str] = Field(None, description="Name of the node")
+    power_state: Optional[str] = Field(None, description="Current power state")
+    provision_state: Optional[str] = Field(None, description="Current provision state")
+    maintenance: bool = Field(..., description="Whether node is in maintenance mode")
+    instance_uuid: Optional[str] = Field(
+        None, description="UUID of associated instance"
+    )
+    driver: Optional[str] = Field(None, description="Driver used for the node")
+    resource_class: Optional[str] = Field(
+        None, description="Resource class of the node"
+    )
+    properties: Dict[str, Any] = Field(
+        default_factory=dict, description="Node properties"
+    )
+    extra: Dict[str, Any] = Field(
+        default_factory=dict, description="Extra node information"
+    )
+    last_error: Optional[str] = Field(None, description="Last error message")
+    created_at: Optional[str] = Field(None, description="Creation timestamp")
+    updated_at: Optional[str] = Field(None, description="Last update timestamp")
+
+
+class BaremetalNodesResponse(BaseModel):
+    nodes: list[BaremetalNode] = Field(..., description="List of baremetal nodes")
+    count: int = Field(..., description="Total number of nodes")
+
+
 def find_device_by_identifier(identifier: str):
     """Find a device in NetBox by various identifiers."""
     if not utils.nb:
@@ -188,6 +217,31 @@ async def write_sink_events(request: Request) -> SinkResponse:
         )
 
 
+@app.get(
+    "/v1/baremetal/nodes", response_model=BaremetalNodesResponse, tags=["baremetal"]
+)
+async def get_baremetal_nodes_list() -> BaremetalNodesResponse:
+    """Get list of all baremetal nodes managed by Ironic.
+
+    Returns information similar to the 'baremetal list' command,
+    including node details, power state, provision state, and more.
+    """
+    try:
+        # Use the generalized function to get baremetal nodes
+        nodes_data = openstack.get_baremetal_nodes()
+
+        # Convert to response model
+        nodes = [BaremetalNode(**node) for node in nodes_data]
+
+        return BaremetalNodesResponse(nodes=nodes, count=len(nodes))
+    except Exception as e:
+        logger.error(f"Error retrieving baremetal nodes: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to retrieve baremetal nodes: {str(e)}",
+        )
+
+
 @app.post("/v1/notifications/baremetal", status_code=204, tags=["notifications"])
 async def notifications_baremetal(notification: NotificationBaremetal) -> None:
     """Handle baremetal notifications."""

osism/commands/baremetal.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from cliff.command import Command
+from argparse import BooleanOptionalAction
 
 import tempfile
 import os
@@ -533,3 +534,170 @@ class BaremetalPing(Command):
         except Exception as e:
             logger.error(f"Error during ping operation: {e}")
             return
+
+
+class BaremetalBurnIn(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalBurnIn, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Run burn-in on given baremetal node when in provision state available",
+        )
+        parser.add_argument(
+            "--all",
+            default=False,
+            help="Run burn-in on all baremetal nodes in provision state available",
+            action="store_true",
+        )
+        parser.add_argument(
+            "--cpu",
+            default=True,
+            help="Enable CPU burn-in",
+            action=BooleanOptionalAction,
+        )
+        parser.add_argument(
+            "--memory",
+            default=True,
+            help="Enable memory burn-in",
+            action=BooleanOptionalAction,
+        )
+        parser.add_argument(
+            "--disk",
+            default=True,
+            help="Enable disk burn-in",
+            action=BooleanOptionalAction,
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        all_nodes = parsed_args.all
+        name = parsed_args.name
+
+        stressor = {}
+        stressor["cpu"] = parsed_args.cpu
+        stressor["memory"] = parsed_args.memory
+        stressor["disk"] = parsed_args.disk
+
+        if not all_nodes and not name:
+            logger.error("Please specify a node name or use --all")
+            return
+
+        clean_steps = []
+        for step, activated in stressor.items():
+            if activated:
+                clean_steps.append({"step": "burnin_" + step, "interface": "deploy"})
+        if not clean_steps:
+            logger.error(
+                f"Please specify at least one of {', '.join(stressor.keys())} for burn-in"
+            )
+            return
+
+        conn = get_cloud_connection()
+
+        if all_nodes:
+            burn_in_nodes = list(conn.baremetal.nodes(details=True))
+        else:
+            node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+            if not node:
+                logger.warning(f"Could not find node {name}")
+                return
+            burn_in_nodes = [node]
+
+        for node in burn_in_nodes:
+            if not node:
+                continue
+
+            if node.provision_state in ["available"]:
+                # NOTE: Burn-In is available in the "manageable" provision state, so we move the node into this state
+                try:
+                    node = conn.baremetal.set_node_provision_state(node.id, "manage")
+                    node = conn.baremetal.wait_for_nodes_provision_state(
+                        [node.id], "manageable"
+                    )[0]
+                except Exception as exc:
+                    logger.warning(
+                        f"Node {node.name} ({node.id}) could not be moved to manageable state: {exc}"
+                    )
+                    continue
+
+            if node.provision_state in ["manageable"]:
+                try:
+                    conn.baremetal.set_node_provision_state(
+                        node.id, "clean", clean_steps=clean_steps
+                    )
+                except Exception as exc:
+                    logger.warning(
+                        f"Burn-In of node {node.name} ({node.id}) failed: {exc}"
+                    )
+                    continue
+            else:
+                logger.warning(
+                    f"Node {node.name} ({node.id}) not in supported state! Provision state: {node.provision_state}, maintenance mode: {node['maintenance']}"
+                )
+                continue
+
+
+class BaremetalMaintenanceSet(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalMaintenanceSet, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Set maintenance on given baremetal node",
+        )
+        parser.add_argument(
+            "--reason",
+            default=None,
+            type=str,
+            help="Reason for maintenance",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        name = parsed_args.name
+        reason = parsed_args.reason
+
+        conn = get_cloud_connection()
+        node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+        if not node:
+            logger.warning(f"Could not find node {name}")
+            return
+        try:
+            conn.baremetal.set_node_maintenance(node, reason=reason)
+        except Exception as exc:
+            logger.error(
+                f"Setting maintenance mode on node {node.name} ({node.id}) failed: {exc}"
+            )
+
+
+class BaremetalMaintenanceUnset(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalMaintenanceUnset, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Unset maintenance on given baremetal node",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        name = parsed_args.name
+
+        conn = get_cloud_connection()
+        node = conn.baremetal.find_node(name, ignore_missing=True, details=True)
+        if not node:
+            logger.warning(f"Could not find node {name}")
+            return
+        try:
+            conn.baremetal.unset_node_maintenance(node)
+        except Exception as exc:
+            logger.error(
+                f"Unsetting maintenance mode on node {node.name} ({node.id}) failed: {exc}"
+            )

osism/commands/netbox.py

@@ -228,9 +228,9 @@ class Console(Command):
         if not os.path.exists(nbcli_file):
             try:
                 with open("/run/secrets/NETBOX_TOKEN", "r") as fp:
-                    token = fp.read().strip()
+                    token = str(fp.read().strip())
             except FileNotFoundError:
-                token = None
+                token = ""
 
             url = os.environ.get("NETBOX_API", None)
 

osism/settings.py

@@ -24,7 +24,7 @@ REDIS_DB: int = int(os.getenv("REDIS_DB", "0"))
 
 
 NETBOX_URL = os.getenv("NETBOX_API", os.getenv("NETBOX_URL"))
-NETBOX_TOKEN = os.getenv("NETBOX_TOKEN", read_secret("NETBOX_TOKEN"))
+NETBOX_TOKEN = str(os.getenv("NETBOX_TOKEN") or read_secret("NETBOX_TOKEN") or "")
 IGNORE_SSL_ERRORS = os.getenv("IGNORE_SSL_ERRORS", "True") == "True"
 
 # 43200 seconds = 12 hours

osism/tasks/conductor/ironic.py

@@ -160,27 +160,36 @@ def sync_ironic(request_id, get_ironic_parameters, node_name=None, force_update=
 
     # Filter nodes by node_name if specified
     if node_name:
-        nodes = [node for node in nodes if node["Name"] == node_name]
+        nodes = [node for node in nodes if node["name"] == node_name]
 
     for node in nodes:
         osism_utils.push_task_output(
-            request_id, f"Looking for {node['Name']} in NetBox\n"
+            request_id, f"Looking for {node['name']} in NetBox\n"
         )
-        if node["Name"] not in device_names:
+        if node["name"] not in device_names:
             if (
-                not node["Instance UUID"]
-                and node["Provisioning State"] in ["enroll", "manageable", "available"]
-                and node["Power State"] in ["power off", None]
+                not node["instance_uuid"]
+                and node["provision_state"]
+                in ["enroll", "manageable", "available", "clean failed"]
+                and node["power_state"] in ["power off", None]
             ):
                 osism_utils.push_task_output(
                     request_id,
-                    f"Cleaning up baremetal node not found in NetBox: {node['Name']}\n",
+                    f"Cleaning up baremetal node not found in NetBox: {node['name']}\n",
                 )
+                if node["provision_state"] == "clean failed":
+                    # NOTE: Move node to manageable to allow deletion
+                    node = openstack.baremetal_node_set_provision_state(
+                        node["uuid"], "manage"
+                    )
+                    node = openstack.baremetal_node_wait_for_nodes_provision_state(
+                        node["uuid"], "manageable"
+                    )
                 for port in openstack.baremetal_port_list(
-                    details=False, attributes=dict(node_uuid=node["UUID"])
+                    details=False, attributes=dict(node_uuid=node["uuid"])
                 ):
                     openstack.baremetal_port_delete(port.id)
-                openstack.baremetal_node_delete(node["UUID"])
+                openstack.baremetal_node_delete(node["uuid"])
             else:
                 osism_utils.push_task_output(
                     f"Cannot remove baremetal node because it is still provisioned or running: {node}"
@@ -218,13 +227,9 @@ def sync_ironic(request_id, get_ironic_parameters, node_name=None, force_update=
                     node = openstack.baremetal_node_create(device.name, node_attributes)
                 else:
                     # NOTE: The listener service only reacts to changes in the baremetal node. Explicitly sync provision and power state in case updates were missed by the listener.
-                    if (
-                        device.custom_fields["provision_state"]
-                        != node["provision_state"]
-                    ):
-                        netbox.set_provision_state(device.name, node["provision_state"])
-                    if device.custom_fields["power_state"] != node["power_state"]:
-                        netbox.set_power_state(device.name, node["power_state"])
+                    # This sync is done unconditionally, because we do not know the state of secondary netboxes at this point
+                    netbox.set_provision_state(device.name, node["provision_state"])
+                    netbox.set_power_state(device.name, node["power_state"])
                     # NOTE: Check whether the baremetal node needs to be updated
                     node_updates = {}
                     deep_compare(node_attributes, node, node_updates)
@@ -280,7 +285,7 @@ def sync_ironic(request_id, get_ironic_parameters, node_name=None, force_update=
                         request_id,
                         f"Validation of management interface successful for baremetal node for {device.name}\n",
                     )
-                    if node["provision_state"] == "enroll":
+                    if node["provision_state"] in ["enroll", "clean failed"]:
                         osism_utils.push_task_output(
                             request_id,
                             f"Transitioning baremetal node to manageable state for {device.name}\n",

osism/tasks/conductor/netbox.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
-from loguru import logger
+import ipaddress
 import yaml
+from loguru import logger
 
 from osism import settings, utils
 from osism.tasks import netbox
@@ -309,3 +310,59 @@ def get_device_loopbacks(device):
         )
 
     return {"loopbacks": loopbacks}
+
+
+def get_device_interface_ips(device):
+    """Get IPv4 addresses assigned to device interfaces.
+
+    Args:
+        device: NetBox device object
+
+    Returns:
+        dict: Dictionary mapping interface names to their IPv4 addresses
+              {
+                  'interface_name': 'ip_address/prefix_length',
+                  ...
+              }
+    """
+    interface_ips = {}
+
+    try:
+        # Get all interfaces for the device
+        interfaces = list(utils.nb.dcim.interfaces.filter(device_id=device.id))
+
+        for interface in interfaces:
+            # Skip management interfaces and virtual interfaces for now
+            if interface.mgmt_only or (
+                hasattr(interface, "type")
+                and interface.type
+                and interface.type.value == "virtual"
+            ):
+                continue
+
+            # Get IP addresses assigned to this interface
+            ip_addresses = utils.nb.ipam.ip_addresses.filter(
+                assigned_object_id=interface.id,
+            )
+
+            for ip_addr in ip_addresses:
+                if ip_addr.address:
+                    # Check if it's an IPv4 address
+                    try:
+                        ip_obj = ipaddress.ip_interface(ip_addr.address)
+                        if ip_obj.version == 4:
+                            interface_ips[interface.name] = ip_addr.address
+                            logger.debug(
+                                f"Found IPv4 address {ip_addr.address} on interface {interface.name} of device {device.name}"
+                            )
+                            break  # Only use the first IPv4 address found
+                    except (ValueError, ipaddress.AddressValueError):
+                        # Skip invalid IP addresses
+                        continue
+
+    except Exception as e:
+        logger.warning(
+            f"Could not get interface IP addresses for device {device.name}: {e}"
+        )
+
+    return interface_ips

osism/tasks/conductor/sonic/config_generator.py

@@ -11,6 +11,7 @@ from loguru import logger
 
 from osism import utils
 from osism.tasks.conductor.netbox import (
+    get_device_interface_ips,
     get_device_loopbacks,
     get_device_oob_ip,
     get_device_vlans,
@@ -29,6 +30,7 @@ from .interface import (
 from .connections import (
     get_connected_interfaces,
     get_connected_device_for_sonic_interface,
+    get_connected_interface_ipv4_address,
 )
 from .cache import get_cached_device_interfaces
 
@@ -73,6 +75,12 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
     # Get Loopback configuration from NetBox
     loopback_info = get_device_loopbacks(device)
 
+    # Get interface IP addresses from NetBox
+    interface_ips = get_device_interface_ips(device)
+
+    # Get IPv4 addresses from transfer role prefixes
+    transfer_ips = _get_transfer_role_ipv4_addresses(device)
+
     # Get breakout port configuration from NetBox
     breakout_info = detect_breakout_ports(device)
 
@@ -186,7 +194,14 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
     )
 
     # Add interface configurations
-    _add_interface_configurations(config, connected_interfaces, portchannel_info)
+    _add_interface_configurations(
+        config,
+        connected_interfaces,
+        portchannel_info,
+        interface_ips,
+        netbox_interfaces,
+        device,
+    )
 
     # Add BGP configurations
     _add_bgp_configurations(
@@ -196,6 +211,10 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
         portchannel_info,
         device,
         device_as_mapping,
+        interface_ips,
+        netbox_interfaces,
+        transfer_ips,
+        utils.nb,
     )
 
     # Add NTP server configuration (device-specific)
@@ -531,7 +550,14 @@ def _add_tagged_vlans_to_ports(config, vlan_info, netbox_interfaces, device):
             config["PORT"][port_name]["tagged_vlans"] = tagged_vlans
 
 
-def _add_interface_configurations(config, connected_interfaces, portchannel_info):
+def _add_interface_configurations(
+    config,
+    connected_interfaces,
+    portchannel_info,
+    interface_ips,
+    netbox_interfaces,
+    device,
+):
     """Add INTERFACE configuration for connected interfaces."""
     for port_name in config["PORT"]:
         # Check if this port is in the connected interfaces set and not a port channel member
@@ -539,8 +565,148 @@ def _add_interface_configurations(config, connected_interfaces, portchannel_info
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            # Add interface to INTERFACE section with ipv6_use_link_local_only enabled
-            config["INTERFACE"][port_name] = {"ipv6_use_link_local_only": "enable"}
+            # Find the NetBox interface name for this SONiC port
+            netbox_interface_name = None
+            if port_name in netbox_interfaces:
+                netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+
+            # Check if this interface has an IPv4 address assigned
+            ipv4_address = None
+            if netbox_interface_name and netbox_interface_name in interface_ips:
+                ipv4_address = interface_ips[netbox_interface_name]
+                logger.info(
+                    f"Interface {port_name} ({netbox_interface_name}) has IPv4 address: {ipv4_address}"
+                )
+
+            if ipv4_address:
+                # If IPv4 address is available, configure the interface with it
+                # Add base interface entry (similar to VLAN_INTERFACE and LOOPBACK_INTERFACE patterns)
+                config["INTERFACE"][port_name] = {}
+                # Add IP address suffixed entry with scope and family parameters
+                config["INTERFACE"][f"{port_name}|{ipv4_address}"] = {
+                    "scope": "global",
+                    "family": "IPv4",
+                }
+                logger.info(
+                    f"Configured interface {port_name} with IPv4 address {ipv4_address}"
+                )
+            else:
+                # Add interface to INTERFACE section with ipv6_use_link_local_only enabled
+                config["INTERFACE"][port_name] = {"ipv6_use_link_local_only": "enable"}
+                logger.debug(
+                    f"Configured interface {port_name} with IPv6 link-local only"
+                )
+
+
+def _get_transfer_role_ipv4_addresses(device):
+    """Get IPv4 addresses from IP prefixes with 'transfer' role.
+
+    Args:
+        device: NetBox device object
+
+    Returns:
+        dict: Dictionary mapping interface names to their transfer role IPv4 addresses
+              {
+                  'interface_name': 'ip_address/prefix_length',
+                  ...
+              }
+    """
+    transfer_ips = {}
+
+    try:
+        # Get all interfaces for the device
+        interfaces = list(utils.nb.dcim.interfaces.filter(device_id=device.id))
+
+        for interface in interfaces:
+            # Skip management interfaces and virtual interfaces
+            if interface.mgmt_only or (
+                hasattr(interface, "type")
+                and interface.type
+                and interface.type.value == "virtual"
+            ):
+                continue
+
+            # Get IP addresses assigned to this interface
+            ip_addresses = utils.nb.ipam.ip_addresses.filter(
+                assigned_object_id=interface.id,
+            )
+
+            for ip_addr in ip_addresses:
+                if ip_addr.address:
+                    try:
+                        ip_obj = ipaddress.ip_interface(ip_addr.address)
+                        if ip_obj.version == 4:
+                            # Check if this IP belongs to a prefix with 'transfer' role
+                            # Query for the prefix this IP belongs to
+                            prefixes = utils.nb.ipam.prefixes.filter(
+                                contains=str(ip_obj.ip)
+                            )
+
+                            for prefix in prefixes:
+                                # Check if prefix has role and it's 'transfer'
+                                if hasattr(prefix, "role") and prefix.role:
+                                    if prefix.role.slug == "transfer":
+                                        transfer_ips[interface.name] = ip_addr.address
+                                        logger.debug(
+                                            f"Found transfer role IPv4 {ip_addr.address} on interface {interface.name} of device {device.name}"
+                                        )
+                                        break
+
+                            # Break after first IPv4 found (transfer or not)
+                            if interface.name in transfer_ips:
+                                break
+                    except (ValueError, ipaddress.AddressValueError):
+                        # Skip invalid IP addresses
+                        continue
+
+    except Exception as e:
+        logger.warning(
+            f"Failed to get transfer role IPv4 addresses for device {device.name}: {e}"
+        )
+
+    return transfer_ips
+
+
+def _has_direct_ipv4_address(port_name, interface_ips, netbox_interfaces):
+    """Check if an interface has a direct IPv4 address assigned.
+
+    Args:
+        port_name: SONiC interface name (e.g., "Ethernet0")
+        interface_ips: Dict mapping NetBox interface names to IPv4 addresses
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+
+    Returns:
+        bool: True if interface has a direct IPv4 address, False otherwise
+    """
+    if not interface_ips or not netbox_interfaces:
+        return False
+
+    if port_name in netbox_interfaces:
+        netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+        return netbox_interface_name in interface_ips
+
+    return False
+
+
+def _has_transfer_role_ipv4(port_name, transfer_ips, netbox_interfaces):
+    """Check if an interface has an IPv4 from a transfer role prefix.
+
+    Args:
+        port_name: SONiC interface name (e.g., "Ethernet0")
+        transfer_ips: Dict mapping NetBox interface names to transfer role IPv4 addresses
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+
+    Returns:
+        bool: True if interface has a transfer role IPv4 address, False otherwise
+    """
+    if not transfer_ips or not netbox_interfaces:
+        return False
+
+    if port_name in netbox_interfaces:
+        netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+        return netbox_interface_name in transfer_ips
+
+    return False
 
 
 def _add_bgp_configurations(
@@ -550,52 +716,189 @@ def _add_bgp_configurations(
     portchannel_info,
     device,
     device_as_mapping=None,
+    interface_ips=None,
+    netbox_interfaces=None,
+    transfer_ips=None,
+    netbox=None,
 ):
-    """Add BGP configurations."""
+    """Add BGP configurations.
+
+    Args:
+        config: Configuration dictionary to update
+        connected_interfaces: Set of connected interface names
+        connected_portchannels: Set of connected port channel names
+        portchannel_info: Port channel membership information
+        device: NetBox device object
+        device_as_mapping: Mapping of device names to AS numbers
+        interface_ips: Dict of direct IPv4 addresses on interfaces
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+        transfer_ips: Dict of IPv4 addresses from transfer role prefixes
+        netbox: NetBox API client for querying connected interface IPs
+    """
     # Add BGP_NEIGHBOR_AF configuration for connected interfaces
     for port_name in config["PORT"]:
+        has_direct_ipv4 = _has_direct_ipv4_address(
+            port_name, interface_ips, netbox_interfaces
+        )
+        has_transfer_ipv4 = _has_transfer_role_ipv4(
+            port_name, transfer_ips, netbox_interfaces
+        )
+
         if (
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            ipv4_key = f"default|{port_name}|ipv4_unicast"
-            ipv6_key = f"default|{port_name}|ipv6_unicast"
-            config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
-            config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
+            # Include interfaces with transfer role IPv4 or no direct IPv4
+            if has_transfer_ipv4 or not has_direct_ipv4:
+                # Try to get the IPv4 address of the connected endpoint interface
+                connected_ipv4 = None
+                if netbox:
+                    connected_ipv4 = get_connected_interface_ipv4_address(
+                        device, port_name, netbox
+                    )
+
+                # For BGP_NEIGHBOR_AF, always use interface name like IPv6 does
+                neighbor_id = port_name
+
+                ipv4_key = f"default|{neighbor_id}|ipv4_unicast"
+                config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
+
+                # Only add ipv6_unicast if v6only would be true (no transfer role IPv4)
+                if not has_transfer_ipv4:
+                    ipv6_key = f"default|{neighbor_id}|ipv6_unicast"
+                    config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR_AF with ipv4_unicast and ipv6_unicast for interface {port_name} (no direct IPv4)"
+                    )
+                else:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR_AF with ipv4_unicast only for interface {port_name} (transfer role IPv4, v6only=false)"
+                    )
+            elif has_direct_ipv4 and not has_transfer_ipv4:
+                logger.info(
+                    f"Excluding interface {port_name} from BGP detection (has direct IPv4 address, not transfer role)"
+                )
 
     # Add BGP_NEIGHBOR_AF configuration for connected port channels
     for pc_name in connected_portchannels:
-        ipv4_key = f"default|{pc_name}|ipv4_unicast"
-        ipv6_key = f"default|{pc_name}|ipv6_unicast"
+        # Try to get the IPv4 address of the connected endpoint interface for port channel
+        connected_ipv4 = None
+        if netbox:
+            connected_ipv4 = get_connected_interface_ipv4_address(
+                device, pc_name, netbox
+            )
+
+        # For BGP_NEIGHBOR_AF, always use port channel name like interfaces
+        neighbor_id = pc_name
+
+        ipv4_key = f"default|{neighbor_id}|ipv4_unicast"
+        ipv6_key = f"default|{neighbor_id}|ipv6_unicast"
         config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
         config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
 
     # Add BGP_NEIGHBOR configuration for connected interfaces
     for port_name in config["PORT"]:
+        has_direct_ipv4 = _has_direct_ipv4_address(
+            port_name, interface_ips, netbox_interfaces
+        )
+        has_transfer_ipv4 = _has_transfer_role_ipv4(
+            port_name, transfer_ips, netbox_interfaces
+        )
+
         if (
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            neighbor_key = f"default|{port_name}"
+            # Include interfaces with transfer role IPv4 or no direct IPv4
+            if has_transfer_ipv4 or not has_direct_ipv4:
+                # Try to get the IPv4 address of the connected endpoint interface
+                connected_ipv4 = None
+                if netbox:
+                    connected_ipv4 = get_connected_interface_ipv4_address(
+                        device, port_name, netbox
+                    )
 
-            # Determine peer_type based on connected device AS
-            peer_type = "external"  # Default
-            connected_device = get_connected_device_for_sonic_interface(
-                device, port_name
-            )
-            if connected_device:
-                peer_type = _determine_peer_type(
-                    device, connected_device, device_as_mapping
+                # Use the connected interface's IPv4 address if available, otherwise use interface name
+                if connected_ipv4:
+                    neighbor_key = f"default|{connected_ipv4}"
+                    logger.debug(
+                        f"Using connected interface IPv4 address {connected_ipv4} for BGP neighbor on {port_name}"
+                    )
+                else:
+                    neighbor_key = f"default|{port_name}"
+                    logger.debug(
+                        f"No connected interface IPv4 found, using interface name {port_name} for BGP neighbor"
+                    )
+
+                # Determine peer_type based on connected device AS
+                peer_type = "external"  # Default
+                connected_device = get_connected_device_for_sonic_interface(
+                    device, port_name
                 )
+                if connected_device:
+                    peer_type = _determine_peer_type(
+                        device, connected_device, device_as_mapping
+                    )
 
-            config["BGP_NEIGHBOR"][neighbor_key] = {
-                "peer_type": peer_type,
-                "v6only": "true",
-            }
+                # Set v6only based on whether interface has transfer role IPv4
+                # - Transfer role IPv4: v6only=false (dual-stack BGP)
+                # - No direct IPv4: v6only=true (IPv6-only BGP)
+                bgp_neighbor_config = {
+                    "peer_type": peer_type,
+                    "v6only": "false" if has_transfer_ipv4 else "true",
+                }
+
+                # If using IP address as key, also store the local address
+                if connected_ipv4:
+                    # Get the local interface IPv4 address
+                    local_ipv4 = None
+                    if port_name in netbox_interfaces:
+                        netbox_interface_name = netbox_interfaces[port_name][
+                            "netbox_name"
+                        ]
+                        if netbox_interface_name in interface_ips:
+                            local_ipv4 = interface_ips[netbox_interface_name].split(
+                                "/"
+                            )[0]
+                        elif netbox_interface_name in transfer_ips:
+                            local_ipv4 = transfer_ips[netbox_interface_name].split("/")[
+                                0
+                            ]
+
+                    if local_ipv4:
+                        bgp_neighbor_config["local_addr"] = local_ipv4
+
+                config["BGP_NEIGHBOR"][neighbor_key] = bgp_neighbor_config
+
+                if has_transfer_ipv4:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR for interface {port_name} (transfer role IPv4, v6only=false)"
+                    )
+                else:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR for interface {port_name} (no direct IPv4, v6only=true)"
+                    )
 
     # Add BGP_NEIGHBOR configuration for connected port channels
     for pc_name in connected_portchannels:
-        neighbor_key = f"default|{pc_name}"
+        # Try to get the IPv4 address of the connected endpoint interface for port channel
+        connected_ipv4 = None
+        if netbox:
+            connected_ipv4 = get_connected_interface_ipv4_address(
+                device, pc_name, netbox
+            )
+
+        # Use the connected interface's IPv4 address if available, otherwise use port channel name
+        if connected_ipv4:
+            neighbor_key = f"default|{connected_ipv4}"
+            logger.debug(
+                f"Using connected interface IPv4 address {connected_ipv4} for BGP neighbor on {pc_name}"
+            )
+        else:
+            neighbor_key = f"default|{pc_name}"
+            logger.debug(
+                f"No connected interface IPv4 found, using port channel name {pc_name} for BGP neighbor"
+            )
 
         # Determine peer_type based on connected device AS
         peer_type = "external"  # Default
@@ -605,11 +908,23 @@ def _add_bgp_configurations(
                 device, connected_device, device_as_mapping
             )
 
-        config["BGP_NEIGHBOR"][neighbor_key] = {
+        bgp_neighbor_config = {
             "peer_type": peer_type,
             "v6only": "true",
         }
 
+        # If using IP address as key, also store the local address
+        if connected_ipv4:
+            # For port channels, get the local IPv4 address from interface IPs
+            # Note: Port channels don't have direct IP assignments in NetBox,
+            # so we use the connected interface IP logic
+            local_ipv4 = None
+            # Port channels don't have NetBox interface entries,
+            # so we skip local_addr for port channels for now
+            # TODO: Implement port channel local address lookup if needed
+
+        config["BGP_NEIGHBOR"][neighbor_key] = bgp_neighbor_config
+
 
 def _get_connected_device_for_interface(device, interface_name):
     """Get the connected device for a given interface name.

osism/tasks/conductor/sonic/connections.py

@@ -387,3 +387,126 @@ def get_device_bgp_neighbors_via_loopback(
         logger.warning(f"Could not process BGP neighbors for device {device.name}: {e}")
 
     return bgp_neighbors
+
+
+def get_connected_interface_ipv4_address(device, sonic_port_name, netbox):
+    """
+    Get the IPv4 address(es) of the connected endpoint interface for a given SONiC port.
+    Checks for direct IP addresses first, then for FHRP VIP addresses.
+
+    Args:
+        device: The SONiC device
+        sonic_port_name: The SONiC port name
+        netbox: The NetBox API client
+
+    Returns:
+        - For direct IP: The IPv4 address string of the connected interface
+        - For FHRP VIP: The first VIP address found (if multiple VIPs exist, logs all but returns first)
+        - None if no addresses found
+    """
+    try:
+        interface = netbox.dcim.interfaces.get(
+            device_id=device.id, name=sonic_port_name
+        )
+        if not interface:
+            return None
+
+        # Check if interface has connected_endpoints using the modern API
+        if not (
+            hasattr(interface, "connected_endpoints") and interface.connected_endpoints
+        ):
+            return None
+
+        # Ensure connected_endpoints_reachable is True
+        if not getattr(interface, "connected_endpoints_reachable", False):
+            return None
+
+        # Process each connected endpoint to find the first valid interface
+        connected_interface = None
+        for endpoint in interface.connected_endpoints:
+            if hasattr(endpoint, "id"):
+                connected_interface = endpoint
+                break
+
+        if not connected_interface:
+            return None
+
+        # First, try to get direct IPv4 addresses assigned to the connected interface
+        ip_addresses = netbox.ipam.ip_addresses.filter(
+            assigned_object_id=connected_interface.id,
+        )
+
+        for ip_address in ip_addresses:
+            # Check if it's an IPv4 address
+            if "/" in str(ip_address.address):
+                address = str(ip_address.address).split("/")[0]
+                if "." in address:  # IPv4 address
+                    logger.debug(
+                        f"Found direct IPv4 address {address} on connected interface "
+                        f"{connected_interface.name} for port {sonic_port_name}"
+                    )
+                    return address
+
+        # If no direct IP found, check for FHRP group membership and VIP addresses
+        logger.debug(
+            f"No direct IPv4 found on {connected_interface.name}, checking for FHRP VIP addresses"
+        )
+
+        # Get FHRP group assignments for the connected interface
+        fhrp_assignments = netbox.ipam.fhrp_group_assignments.filter(
+            interface_type="dcim.interface", interface_id=connected_interface.id
+        )
+
+        # Get all VIP addresses once to avoid repeated API calls
+        try:
+            all_vip_addresses = netbox.ipam.ip_addresses.filter(role="vip")
+        except Exception as vip_e:
+            logger.debug(f"Could not query VIP addresses: {vip_e}")
+            all_vip_addresses = []
+
+        # Collect all VIP IPv4 addresses from all FHRP groups this interface belongs to
+        vip_addresses_found = []
+
+        for assignment in fhrp_assignments:
+            if not assignment.group:
+                continue
+
+            # Find VIP addresses assigned to this specific FHRP group
+            for vip in all_vip_addresses:
+                # Check if this VIP is assigned to the current FHRP group
+                if (
+                    hasattr(vip, "assigned_object_type")
+                    and vip.assigned_object_type == "ipam.fhrpgroup"
+                    and hasattr(vip, "assigned_object_id")
+                    and vip.assigned_object_id == assignment.group.id
+                ):
+                    # Check if it's an IPv4 address
+                    if "/" in str(vip.address):
+                        address = str(vip.address).split("/")[0]
+                        if "." in address:  # IPv4 address
+                            vip_addresses_found.append(address)
+                            logger.debug(
+                                f"Found FHRP VIP address {address} for connected interface "
+                                f"{connected_interface.name} (FHRP group: {assignment.group.name or assignment.group.id}) "
+                                f"for port {sonic_port_name}"
+                            )
+
+        # Return the first VIP address found (for BGP neighbor compatibility)
+        if vip_addresses_found:
+            logger.debug(
+                f"Found {len(vip_addresses_found)} VIP addresses for port {sonic_port_name}: {vip_addresses_found}"
+            )
+            logger.debug(f"Returning first VIP address: {vip_addresses_found[0]}")
+            return vip_addresses_found[0]
+
+        logger.debug(
+            f"No IPv4 address (direct or FHRP VIP) found on connected interface "
+            f"{connected_interface.name} for port {sonic_port_name}"
+        )
+        return None
+
+    except Exception as e:
+        logger.warning(
+            f"Could not get connected interface IPv4 for port {sonic_port_name}: {e}"
+        )
+        return None

osism/tasks/conductor/sonic/interface.py

@@ -697,7 +697,9 @@ def detect_breakout_ports(device):
                                     )
 
                                 # Calculate breakout mode
-                                if interface_speed == 25000 and num_subports == 4:
+                                if interface_speed == 10000 and num_subports == 4:
+                                    brkout_mode = "4x10G"
+                                elif interface_speed == 25000 and num_subports == 4:
                                     brkout_mode = "4x25G"
                                 elif interface_speed == 50000 and num_subports == 4:
                                     brkout_mode = "4x50G"

osism/tasks/openstack.py

@@ -65,23 +65,43 @@ def baremetal_node_show(self, node_id_or_name, ignore_missing=False):
 @app.task(bind=True, name="osism.tasks.openstack.baremetal_node_list")
 def baremetal_node_list(self):
     conn = utils.get_openstack_connection()
-    nodes = conn.baremetal.nodes()
-    result = []
+    result = conn.baremetal.nodes()
+    return list(result)
 
-    # Simulate the output of the OpenStack CLI with -f json and without --long
-    for node in nodes:
-        result.append(
-            {
-                "UUID": node.id,
-                "Name": node.name,
-                "Instance UUID": node.instance_id,
-                "Power State": node.power_state,
-                "Provisioning State": node.provision_state,
-                "Maintenance": node.is_maintenance,
-            }
-        )
 
-    return result
+def get_baremetal_nodes():
+    """Get all baremetal nodes with their details.
+
+    This is a generalized function that can be used by both
+    CLI commands and API endpoints to retrieve baremetal node information.
+
+    Returns:
+        list: List of dictionaries containing node information
+    """
+    conn = utils.get_openstack_connection()
+    nodes = conn.baremetal.nodes(details=True)
+
+    # Convert generator to list and extract relevant fields
+    node_list = []
+    for node in nodes:
+        node_info = {
+            "uuid": node.get("uuid"),
+            "name": node.get("name"),
+            "power_state": node.get("power_state"),
+            "provision_state": node.get("provision_state"),
+            "maintenance": node.get("maintenance"),
+            "instance_uuid": node.get("instance_uuid"),
+            "driver": node.get("driver"),
+            "resource_class": node.get("resource_class"),
+            "properties": node.get("properties", {}),
+            "extra": node.get("extra", {}),
+            "last_error": node.get("last_error"),
+            "created_at": node.get("created_at"),
+            "updated_at": node.get("updated_at"),
+        }
+        node_list.append(node_info)
+
+    return node_list
 
 
 @app.task(bind=True, name="osism.tasks.openstack.baremetal_node_validate")

osism/utils/__init__.py

@@ -73,7 +73,7 @@ try:
             )
         if (
             "NETBOX_TOKEN" not in secondary_nb_settings
-            or not secondary_nb_settings["NETBOX_TOKEN"]
+            or not str(secondary_nb_settings["NETBOX_TOKEN"]).strip()
         ):
             raise ValueError(
                 "All NETBOX_TOKEN values in the elements of setting NETBOX_SECONDARIES need to be valid NetBox tokens"
@@ -82,7 +82,7 @@ try:
         secondary_nb_list.append(
             get_netbox_connection(
                 secondary_nb_settings["NETBOX_URL"],
-                secondary_nb_settings["NETBOX_TOKEN"],
+                str(secondary_nb_settings["NETBOX_TOKEN"]),
                 secondary_nb_settings.get("IGNORE_SSL_ERRORS", True),
             )
         )

{osism-0.20250804.0.dist-info → osism-0.20250823.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osism
-Version: 0.20250804.0
+Version: 0.20250823.0
 Summary: OSISM manager interface
 Home-page: https://github.com/osism/python-osism
 Author: OSISM GmbH
@@ -28,20 +28,20 @@ Requires-Dist: Jinja2==3.1.6
 Requires-Dist: PyYAML==6.0.2
 Requires-Dist: ara==1.7.2
 Requires-Dist: celery[redis]==5.5.3
-Requires-Dist: cliff==4.10.0
-Requires-Dist: deepdiff==8.5.0
+Requires-Dist: cliff==4.11.0
+Requires-Dist: deepdiff==8.6.0
 Requires-Dist: docker==7.1.0
 Requires-Dist: dtrack-auditor==1.5.0
 Requires-Dist: fastapi==0.116.1
 Requires-Dist: flower==2.0.1
 Requires-Dist: hiredis==3.2.1
 Requires-Dist: jc==1.25.5
-Requires-Dist: keystoneauth1==5.11.1
+Requires-Dist: keystoneauth1==5.12.0
 Requires-Dist: kombu==5.5.4
 Requires-Dist: kubernetes==33.1.0
 Requires-Dist: loguru==0.7.3
 Requires-Dist: nbcli==0.10.0.dev2
-Requires-Dist: openstacksdk==4.6.0
+Requires-Dist: openstacksdk==4.7.0
 Requires-Dist: paramiko==3.5.1
 Requires-Dist: pottery==3.0.1
 Requires-Dist: prompt-toolkit==3.0.51
@@ -50,7 +50,7 @@ Requires-Dist: pytest-testinfra==10.2.2
 Requires-Dist: python-dateutil==2.9.0.post0
 Requires-Dist: setuptools==80.9.0
 Requires-Dist: sqlmodel==0.0.24
-Requires-Dist: sushy==5.7.0
+Requires-Dist: sushy==5.7.1
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: transitions==0.9.3
 Requires-Dist: uvicorn[standard]==0.35.0

{osism-0.20250804.0.dist-info → osism-0.20250823.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 osism/__init__.py,sha256=1UiNTBus0V0f2AbZQzAtVtu6zkfCCrw0OTq--NwFAqY,341
 osism/__main__.py,sha256=ILe4gu61xEISiBsxanqTQIdSkV-YhpZXTRlguCYyssk,141
-osism/api.py,sha256=7BKVedr3aK8QSRf4ZI1WpraYivibimx-SqVKVAzD6bw,11070
+osism/api.py,sha256=hhRgBswe3Tem6eTMor54PttNhBhAts2AEDBsxQfqRyU,13363
 osism/main.py,sha256=Dt2-9sLXcS-Ny4DAz7hrha-KRc7zd7BFUTRdfs_X8z4,893
-osism/settings.py,sha256=IUbUo8kru8TeiMAnnil5oHwd8SqbkPCY401dVONMygo,1885
+osism/settings.py,sha256=VZT1muZVYWM5Ov1eFRC7a4ZGYIdI2AFmudCm0wZ1C2Q,1898
 osism/commands/__init__.py,sha256=Ag4wX_DCgXRdoLn6t069jqb3DdRylsX2nyYkiyCx4uk,456
 osism/commands/apply.py,sha256=GWUccZAXlgkPYqylrCmdWcj8FCkDsPEipIIG937MeII,16833
-osism/commands/baremetal.py,sha256=jejkH4oA9SQsjivABBIKuqegTv4G7FqRsIc7soAMj08,19207
+osism/commands/baremetal.py,sha256=TeXwg4lYfxel0YkWC3z8bv9qTsJQmsI2QD6u1K4vhIM,24821
 osism/commands/compose.py,sha256=76HL9wzTJ7bFPhZk-uyfWq0n6Z74lOHn4RE0zzkHgYE,1241
 osism/commands/compute.py,sha256=cgqXWJa5wAvn-7e3FWCgX6hie_aK0yrKRkcNzjLXwDY,25799
 osism/commands/configuration.py,sha256=sPe8b0dVKFRbr30xoeVdAnHbGwCwgUh0xa_Vzv5pSQQ,954
@@ -14,7 +14,7 @@ osism/commands/container.py,sha256=jHk5A0PXBzHGIm-1d5HQZI_POANAq7An1lZGRbqBvr0,1
 osism/commands/get.py,sha256=ryytjtXWmlMV0NucP5tGkMZu0nIlC4xVtjRk4iMZ06c,8967
 osism/commands/log.py,sha256=QnnTTNiAoa8oj4kDOcggh0QrRAD6onxcEpLXBy7CvDg,4113
 osism/commands/manage.py,sha256=FaO9dbYjNHYanS98-zC498bx26oU8E3loxCczH9mfKI,12751
-osism/commands/netbox.py,sha256=K8kP-OA1A65U-Cjrtn2lKxQKf9IdCcsOjQbkBaMSI7Y,8272
+osism/commands/netbox.py,sha256=gqXet5jHIRKFtHkbd6pQ0071jHe4r5c7DFnZWkT_lNQ,8275
 osism/commands/noset.py,sha256=7zDFuFMyNpo7DUOKcNiYV8nodtdMOYFp5LDPcuJhlZ8,1481
 osism/commands/reconciler.py,sha256=ubQfX8j13s3NuMKnT0Lt6O-szf7Z1V02AfsMQFHmO74,2209
 osism/commands/redfish.py,sha256=oBfxd5UBX4ED8XulEuIYziIYQqTvUKpKfcdGyg_AoiI,8431
@@ -42,31 +42,31 @@ osism/tasks/conductor.py,sha256=WBLsoPtr0iGUzRGERs0Xt7CMYrnHQVEwNV9qXBssI3s,274
 osism/tasks/kolla.py,sha256=wJQpWn_01iWLkr7l7T7RNrQGfRgsgmYi4WQlTmNGvew,618
 osism/tasks/kubernetes.py,sha256=VzXq_VrYU_CLm4cOruqnE3Kq2ydfO9glZ3p0bp3OYoc,625
 osism/tasks/netbox.py,sha256=QGQGz3s0V8WvPvhEJWwo0H24aLFaZrSl-voN-axzRwY,5846
-osism/tasks/openstack.py,sha256=g15tCll5vP1pC6ysxRCTZxplsdGmXbxaCH3k1Qdv5Xg,6367
+osism/tasks/openstack.py,sha256=VeNfEcv4JHx_oJxpAb2QO2adlk--hlSqo_2iVQbOtpE,7142
 osism/tasks/reconciler.py,sha256=PnGWfvfmomzbgddvyCdxul-z5ZLXxWAmrQyRCN874-s,1958
 osism/tasks/conductor/__init__.py,sha256=eAiaM69sVbTTDam7gCLyjF7wBCt7rd__pRFu7VdY-f8,1930
 osism/tasks/conductor/config.py,sha256=n1H9_8DY90p5E4mygzKyJUl8G3WdDuGHFTp-SrmZmgU,4543
-osism/tasks/conductor/ironic.py,sha256=Lfwlcp-rJmQ4CA_1K_FtIRrciaXFNKvC976t1lT2RDs,16090
-osism/tasks/conductor/netbox.py,sha256=5Nc7wrriDOtSuru1KDLt9QpA54vC7tXDPB2J0JP9GKo,11393
+osism/tasks/conductor/ironic.py,sha256=sxUHAzs8_Z-IaB5ZZ0ufObWiytBKiptPUWoIGWo2wcY,16440
+osism/tasks/conductor/netbox.py,sha256=xPJn-tXLqTAgW3v6L9rQ__XGHhM7ErchnyfsLY6iH14,13381
 osism/tasks/conductor/redfish.py,sha256=hOOS-_l3Qmo_6vLsgjZmJwTxLTf029hhFRVkU0TMLL0,12723
 osism/tasks/conductor/utils.py,sha256=-vHsyi0Adlk8qdoZkhM2kUwG7DqwwZZVE0JGK5Z92mI,8127
 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
-osism/tasks/conductor/sonic/config_generator.py,sha256=_B001d6YdhLjAl61WGhlF2xyMXvcyJv0TQ16zuzJjB8,40117
-osism/tasks/conductor/sonic/connections.py,sha256=NvRjwJv3NF3ry5Xe9qHzk7pQbfDQHYx_j3ATRMUs7gA,14244
+osism/tasks/conductor/sonic/config_generator.py,sha256=U9tFNdJsZIdk-lzbkodXiWmK4FJq0FplBKKKuP7R27o,53269
+osism/tasks/conductor/sonic/connections.py,sha256=MU3u7HRG42dDlKL5GMruDVSvVl6AUXEf_WivfYdFURE,19297
 osism/tasks/conductor/sonic/constants.py,sha256=HjVFwmH-AN3np1qN97ahEAcwz2-4cHa-pA9pXWqWsqs,2219
 osism/tasks/conductor/sonic/device.py,sha256=ZYJA0bQ8waKWStzWUPxbcwNWa2Z_hMB3pqs8aA_nxXA,2458
 osism/tasks/conductor/sonic/exporter.py,sha256=25L1vbi84ZQD0xNHNTWk-anTz5QRkGJskCECBkeGQw4,8882
-osism/tasks/conductor/sonic/interface.py,sha256=QPiggBbk_APWuwwvoU9JWd5bbsdgip9ehFUlcdBKzyI,39329
+osism/tasks/conductor/sonic/interface.py,sha256=M876LHdFqGxUfTizzDusdzvCkDI0vCgqte5uLmOXFaY,39472
 osism/tasks/conductor/sonic/sync.py,sha256=fpgsQVwq6Hb7eeDHhLkAqx5BkaK3Ce_m_WvmWEsJyOo,9182
-osism/utils/__init__.py,sha256=J2ht-1_9BUV_K6mR6jmk-r_cJKutECFVleEe3-0nU_k,7788
+osism/utils/__init__.py,sha256=370UHVU5BFy-1wDAxBFaRjSA-zR0KNadJPWQ6zcYRf0,7806
 osism/utils/ssh.py,sha256=nxeEgwjJWvQCybKDp-NelMeWyODCYpaXFCBchAv4-bg,8691
-osism-0.20250804.0.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
-osism-0.20250804.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-osism-0.20250804.0.dist-info/METADATA,sha256=-a3c6DmzquHM97ijxB1bwk5xjuj5uSeYyfuRdsSP0Fw,2937
-osism-0.20250804.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-osism-0.20250804.0.dist-info/entry_points.txt,sha256=z3hOkBquB5tKZBLGyMV_lgNlzZAqM3LYdC9gClVHFP0,4140
-osism-0.20250804.0.dist-info/pbr.json,sha256=OhImrPgJ50CxjZ7fzWYj8N0JflRxR4HJjRoABlGltrw,47
-osism-0.20250804.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
-osism-0.20250804.0.dist-info/RECORD,,
+osism-0.20250823.0.dist-info/licenses/AUTHORS,sha256=EKFIR9F27AvoEXp1cA6FkGbjEOFt4Rcbipr5RJc7jSs,64
+osism-0.20250823.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+osism-0.20250823.0.dist-info/METADATA,sha256=ZwWM7UZEXo9p5LSTB5v65qa2aEt3o7UOi7LNSrjkBXE,2937
+osism-0.20250823.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osism-0.20250823.0.dist-info/entry_points.txt,sha256=h9YS3gfPc5ueU9ZXtCc60e8p4NQEuvtIH_zE0cfVqy0,4439
+osism-0.20250823.0.dist-info/pbr.json,sha256=t633u2SKCZHSfZL7F8jKzAb9107KiG9OydBqGXdZPNQ,47
+osism-0.20250823.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
+osism-0.20250823.0.dist-info/RECORD,,

{osism-0.20250804.0.dist-info → osism-0.20250823.0.dist-info}/entry_points.txt

@@ -3,6 +3,7 @@ osism = osism.main:main
 
 [osism.commands]
 apply = osism.commands.apply:Run
+baremetal burnin = osism.commands.baremetal:BaremetalBurnIn
 baremetal deploy = osism.commands.baremetal:BaremetalDeploy
 baremetal list = osism.commands.baremetal:BaremetalList
 baremetal ping = osism.commands.baremetal:BaremetalPing
@@ -30,8 +31,11 @@ log ansible = osism.commands.log:Ansible
 log container = osism.commands.log:Container
 log file = osism.commands.log:File
 log opensearch = osism.commands.log:Opensearch
+manage baremetal burnin = osism.commands.baremetal:BaremetalBurnIn
 manage baremetal deploy = osism.commands.baremetal:BaremetalDeploy
 manage baremetal list = osism.commands.baremetal:BaremetalList
+manage baremetal maintenance set = osism.commands.baremetal:BaremetalMaintenanceSet
+manage baremetal maintenance unset = osism.commands.baremetal:BaremetalMaintenanceUnset
 manage baremetal ping = osism.commands.baremetal:BaremetalPing
 manage baremetal undeploy = osism.commands.baremetal:BaremetalUndeploy
 manage compute disable = osism.commands.compute:ComputeDisable

osism-0.20250823.0.dist-info/licenses/AUTHORS

@@ -0,0 +1 @@
+renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

osism-0.20250823.0.dist-info/pbr.json

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

osism-0.20250804.0.dist-info/licenses/AUTHORS

@@ -1 +0,0 @@
-Christian Berendt <berendt@osism.tech>

osism-0.20250804.0.dist-info/pbr.json

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