osism 0.20250709.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,9 +1,12 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from cliff.command import Command
+from argparse import BooleanOptionalAction
 
 import tempfile
 import os
+import subprocess
+import threading
 from loguru import logger
 import openstack
 from tabulate import tabulate
@@ -13,6 +16,9 @@ from openstack.baremetal import configdrive as configdrive_builder
 
 from osism.commands import get_cloud_connection
 from osism import utils
+from osism.tasks.conductor.netbox import get_nb_device_query_list_ironic
+from osism.tasks import netbox
+from osism.utils.ssh import cleanup_ssh_known_hosts_for_node
 
 
 class BaremetalList(Command):
@@ -57,6 +63,8 @@ class BaremetalList(Command):
             for b in baremetal
         ]
 
+        result.sort(key=lambda x: x[0])
+
         print(
             tabulate(
                 result,
@@ -206,7 +214,7 @@ class BaremetalDeploy(Command):
 
                 playbook = []
                 play = {
-                    "name": "Run bootstrap - part 2",
+                    "name": "Run bootstrap",
                     "hosts": "localhost",
                     "connection": "local",
                     "gather_facts": True,
@@ -216,6 +224,15 @@ class BaremetalDeploy(Command):
                         "osism.commons.hosts",
                         "osism.commons.operator",
                     ],
+                    "tasks": [
+                        {
+                            "name": "Restart rsyslog service after hostname change",
+                            "ansible.builtin.systemd": {
+                                "name": "rsyslog",
+                                "state": "restarted",
+                            },
+                        }
+                    ],
                 }
                 play["vars"].update(
                     {"hostname_name": node.name, "hosts_type": "template"}
@@ -321,9 +338,30 @@ class BaremetalUndeploy(Command):
             if not node:
                 continue
 
-            if node.provision_state in ["active", "deploy failed", "error"]:
+            if node.provision_state in [
+                "active",
+                "wait call-back",
+                "deploy failed",
+                "error",
+            ]:
                 try:
                     node = conn.baremetal.set_node_provision_state(node.id, "undeploy")
+                    logger.info(
+                        f"Successfully initiated undeploy for node {node.name} ({node.id})"
+                    )
+
+                    # Clean up SSH known_hosts entries for the undeployed node
+                    logger.info(f"Cleaning up SSH known_hosts entries for {node.name}")
+                    result = cleanup_ssh_known_hosts_for_node(node.name)
+                    if result:
+                        logger.info(
+                            f"SSH known_hosts cleanup completed successfully for {node.name}"
+                        )
+                    else:
+                        logger.warning(
+                            f"SSH known_hosts cleanup completed with warnings for {node.name}"
+                        )
+
                 except Exception as exc:
                     logger.warning(
                         f"Node {node.name} ({node.id}) could not be moved to available state: {exc}"
@@ -333,3 +371,333 @@ class BaremetalUndeploy(Command):
                 logger.warning(
                     f"Node {node.name} ({node.id}) not in supported provision state"
                 )
+
+
+class BaremetalPing(Command):
+    def get_parser(self, prog_name):
+        parser = super(BaremetalPing, self).get_parser(prog_name)
+        parser.add_argument(
+            "name",
+            nargs="?",
+            type=str,
+            help="Ping specific baremetal node by name",
+        )
+        return parser
+
+    def _ping_host(self, host, results, host_name):
+        """Ping a host 3 times and store results."""
+        try:
+            result = subprocess.run(
+                ["ping", "-c", "3", "-W", "5", host],
+                capture_output=True,
+                text=True,
+                timeout=20,
+            )
+
+            if result.returncode == 0:
+                output_lines = result.stdout.strip().split("\n")
+                stats_line = [line for line in output_lines if "packet loss" in line]
+                if stats_line:
+                    loss_info = stats_line[0]
+                    if "0% packet loss" in loss_info:
+                        status = "SUCCESS"
+                    else:
+                        status = f"PARTIAL ({loss_info.split(',')[2].strip()})"
+                else:
+                    status = "SUCCESS"
+
+                time_lines = [
+                    line
+                    for line in output_lines
+                    if "round-trip" in line or "rtt" in line
+                ]
+                if time_lines:
+                    time_info = (
+                        time_lines[0].split("=")[-1].strip()
+                        if "=" in time_lines[0]
+                        else "N/A"
+                    )
+                else:
+                    time_info = "N/A"
+            else:
+                status = "FAILED"
+                time_info = "N/A"
+
+        except (
+            subprocess.TimeoutExpired,
+            subprocess.CalledProcessError,
+            Exception,
+        ) as e:
+            status = "ERROR"
+            time_info = str(e)[:50]
+
+        results[host_name] = {"host": host, "status": status, "time_info": time_info}
+
+    def take_action(self, parsed_args):
+        name = parsed_args.name
+
+        if not utils.nb:
+            logger.error("NetBox connection not available")
+            return
+
+        conn = get_cloud_connection()
+
+        try:
+            if name:
+                devices = [utils.nb.dcim.devices.get(name=name)]
+                if not devices[0]:
+                    logger.error(f"Device {name} not found in NetBox")
+                    return
+            else:
+                # Use the NETBOX_FILTER_CONDUCTOR_IRONIC setting to get devices
+                devices = set()
+                nb_device_query_list = get_nb_device_query_list_ironic()
+                for nb_device_query in nb_device_query_list:
+                    devices |= set(netbox.get_devices(**nb_device_query))
+                devices = list(devices)
+
+                # Additionally filter by power state and provision state
+                filtered_devices = []
+                for device in devices:
+                    if (
+                        hasattr(device, "custom_fields")
+                        and device.custom_fields
+                        and device.custom_fields.get("power_state") == "power on"
+                        and device.custom_fields.get("provision_state") == "active"
+                    ):
+                        filtered_devices.append(device)
+                devices = filtered_devices
+
+            if not devices:
+                logger.info(
+                    "No devices found matching criteria (managed-by-ironic, power on, active)"
+                )
+                return
+
+            ping_candidates = []
+            for device in devices:
+                if device.primary_ip4:
+                    ip_address = str(device.primary_ip4.address).split("/")[0]
+                    ping_candidates.append({"name": device.name, "ip": ip_address})
+                else:
+                    logger.warning(f"Device {device.name} has no primary IPv4 address")
+
+            if not ping_candidates:
+                logger.info("No devices found with primary IPv4 addresses")
+                return
+
+            logger.info(f"Pinging {len(ping_candidates)} nodes (3 pings each)...")
+
+            results = {}
+            threads = []
+
+            for candidate in ping_candidates:
+                thread = threading.Thread(
+                    target=self._ping_host,
+                    args=(candidate["ip"], results, candidate["name"]),
+                )
+                threads.append(thread)
+                thread.start()
+
+            for thread in threads:
+                thread.join()
+
+            table_data = []
+            success_count = 0
+            failed_count = 0
+
+            for device_name in sorted(results.keys()):
+                result = results[device_name]
+                table_data.append(
+                    [device_name, result["host"], result["status"], result["time_info"]]
+                )
+
+                if result["status"] == "SUCCESS":
+                    success_count += 1
+                elif result["status"].startswith("PARTIAL"):
+                    failed_count += 1
+                else:
+                    failed_count += 1
+
+            print(
+                tabulate(
+                    table_data,
+                    headers=["Name", "IP Address", "Status", "Time Info"],
+                    tablefmt="psql",
+                )
+            )
+
+            print(
+                f"\nSummary: {success_count} successful, {failed_count} failed/partial out of {len(ping_candidates)} total"
+            )
+
+        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/compose.py

@@ -26,7 +26,7 @@ class Run(Command):
         ssh_command = (
             f"docker compose --project-directory=/opt/{environment} {arguments}"
         )
-        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR"
+        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR -o UserKnownHostsFile=/share/known_hosts"
 
         # FIXME: use paramiko or something else more Pythonic + make operator user + key configurable
         subprocess.call(

osism/commands/console.py

@@ -1,10 +1,94 @@
 # SPDX-License-Identifier: Apache-2.0
 
+import socket
 import subprocess
+from typing import Optional
 
 from cliff.command import Command
+from loguru import logger
 from prompt_toolkit import prompt
 
+from osism import utils
+
+
+def resolve_hostname_to_ip(hostname: str) -> Optional[str]:
+    """
+    Attempt to resolve hostname to IPv4 address using DNS.
+
+    Args:
+        hostname: The hostname to resolve
+
+    Returns:
+        IPv4 address string if successful, None if resolution fails
+    """
+    try:
+        ip_address = socket.gethostbyname(hostname)
+        logger.debug(f"Resolved hostname {hostname} to {ip_address}")
+        return ip_address
+    except socket.gaierror as e:
+        logger.debug(f"DNS resolution failed for {hostname}: {e}")
+        return None
+
+
+def get_primary_ipv4_from_netbox(hostname: str) -> Optional[str]:
+    """
+    Retrieve primary IPv4 address for hostname from Netbox.
+
+    Args:
+        hostname: The hostname to look up in Netbox
+
+    Returns:
+        Primary IPv4 address string if found, None otherwise
+    """
+    if not utils.nb:
+        logger.debug("Netbox integration not available")
+        return None
+
+    try:
+        device = utils.nb.dcim.devices.get(name=hostname)
+        if device and device.primary_ip4:
+            ip_address = str(device.primary_ip4.address).split("/")[0]
+            logger.info(f"Found primary IPv4 for {hostname} in Netbox: {ip_address}")
+            return ip_address
+        else:
+            logger.debug(f"No device or primary IPv4 found for {hostname} in Netbox")
+            return None
+    except Exception as e:
+        logger.warning(f"Error querying Netbox for {hostname}: {e}")
+        return None
+
+
+def resolve_host_with_fallback(hostname: str) -> str:
+    """
+    Resolve hostname with Netbox fallback.
+
+    First attempts DNS resolution. If that fails and Netbox integration is enabled,
+    attempts to retrieve the primary IPv4 address from Netbox.
+
+    Args:
+        hostname: The hostname to resolve
+
+    Returns:
+        Resolved IP address or original hostname if all resolution attempts fail
+    """
+    # First try DNS resolution
+    ip_address = resolve_hostname_to_ip(hostname)
+    if ip_address:
+        return ip_address
+
+    # Fallback to Netbox if DNS resolution failed
+    logger.info(f"DNS resolution failed for {hostname}, trying Netbox fallback")
+    netbox_ip = get_primary_ipv4_from_netbox(hostname)
+    if netbox_ip:
+        logger.info(f"Using IPv4 address {netbox_ip} from Netbox for {hostname}")
+        return netbox_ip
+
+    # If both methods fail, return original hostname and let SSH handle the error
+    logger.warning(
+        f"Could not resolve {hostname} via DNS or Netbox, using original hostname"
+    )
+    return hostname
+
 
 class Run(Command):
     def get_parser(self, prog_name):
@@ -45,7 +129,7 @@ class Run(Command):
             type_console = "clush"
             host = host[1:]
 
-        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR"
+        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR -o UserKnownHostsFile=/share/known_hosts"
 
         if type_console == "ansible":
             subprocess.call(f"/run-ansible-console.sh {host}", shell=True)
@@ -55,9 +139,11 @@ class Run(Command):
                 shell=True,
             )
         elif type_console == "ssh":
+            # Resolve hostname with Netbox fallback
+            resolved_host = resolve_host_with_fallback(host)
             # FIXME: use paramiko or something else more Pythonic + make operator user + key configurable
             subprocess.call(
-                f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{host}",
+                f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{resolved_host}",
                 shell=True,
             )
         elif type_console == "container_prompt":
@@ -67,9 +153,11 @@ class Run(Command):
                     break
 
                 ssh_command = f"docker {command}"
+                # Resolve hostname with Netbox fallback
+                resolved_host = resolve_host_with_fallback(host[:-1])
                 # FIXME: use paramiko or something else more Pythonic + make operator user + key configurable
                 subprocess.call(
-                    f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{host[:-1]} {ssh_command}",
+                    f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{resolved_host} {ssh_command}",
                     shell=True,
                 )
         elif type_console == "container":
@@ -78,12 +166,12 @@ class Run(Command):
             target_command = "bash"
 
             ssh_command = f"docker exec -it {target_containername} {target_command}"
-            ssh_options = (
-                "-o RequestTTY=force -o StrictHostKeyChecking=no -o LogLevel=ERROR"
-            )
+            ssh_options = "-o RequestTTY=force -o StrictHostKeyChecking=no -o LogLevel=ERROR -o UserKnownHostsFile=/share/known_hosts"
 
+            # Resolve hostname with Netbox fallback
+            resolved_target_host = resolve_host_with_fallback(target_host)
             # FIXME: use paramiko or something else more Pythonic + make operator user + key configurable
             subprocess.call(
-                f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{target_host} {ssh_command}",
+                f"/usr/bin/ssh -i /ansible/secrets/id_rsa.operator {ssh_options} dragon@{resolved_target_host} {ssh_command}",
                 shell=True,
             )

osism/commands/container.py

@@ -23,7 +23,7 @@ class Run(Command):
         host = parsed_args.host[0]
         command = " ".join(parsed_args.command)
 
-        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR"
+        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR -o UserKnownHostsFile=/share/known_hosts"
 
         if not command:
             while True:

osism/commands/log.py

@@ -52,7 +52,7 @@ class Container(Command):
         parameters = " ".join(parsed_args.parameter)
 
         ssh_command = f"docker logs {parameters} {container_name}"
-        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR"
+        ssh_options = "-o StrictHostKeyChecking=no -o LogLevel=ERROR -o UserKnownHostsFile=/share/known_hosts"
 
         # FIXME: use paramiko or something else more Pythonic + make operator user + key configurable
         subprocess.call(