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

osism/commands/baremetal.py

@@ -4,6 +4,8 @@ from cliff.command import Command
 
 import tempfile
 import os
+import subprocess
+import threading
 from loguru import logger
 import openstack
 from tabulate import tabulate
@@ -13,6 +15,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 +62,8 @@ class BaremetalList(Command):
             for b in baremetal
         ]
 
+        result.sort(key=lambda x: x[0])
+
         print(
             tabulate(
                 result,
@@ -206,7 +213,7 @@ class BaremetalDeploy(Command):
 
                 playbook = []
                 play = {
-                    "name": "Run bootstrap - part 2",
+                    "name": "Run bootstrap",
                     "hosts": "localhost",
                     "connection": "local",
                     "gather_facts": True,
@@ -216,6 +223,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 +337,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 +370,166 @@ 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

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(

osism/commands/netbox.py

@@ -14,6 +14,11 @@ from osism import utils
 class Ironic(Command):
     def get_parser(self, prog_name):
         parser = super(Ironic, self).get_parser(prog_name)
+        parser.add_argument(
+            "node",
+            nargs="?",
+            help="Optional node name to sync only a specific node",
+        )
         parser.add_argument(
             "--no-wait",
             help="Do not wait until the sync has been completed",
@@ -35,22 +40,40 @@ class Ironic(Command):
     def take_action(self, parsed_args):
         wait = not parsed_args.no_wait
         task_timeout = parsed_args.task_timeout
+        node_name = parsed_args.node
 
-        task = conductor.sync_ironic.delay(force_update=parsed_args.force_update)
+        task = conductor.sync_ironic.delay(
+            node_name=node_name, force_update=parsed_args.force_update
+        )
         if wait:
-            logger.info(
-                f"Task {task.task_id} (sync ironic) is running in background. Output comming soon."
-            )
+            if node_name:
+                logger.info(
+                    f"Task {task.task_id} (sync ironic for node {node_name}) is running in background. Output comming soon."
+                )
+            else:
+                logger.info(
+                    f"Task {task.task_id} (sync ironic) is running in background. Output comming soon."
+                )
             try:
                 return utils.fetch_task_output(task.id, timeout=task_timeout)
             except TimeoutError:
-                logger.error(
-                    f"Timeout while waiting for further output of task {task.task_id} (sync ironic)"
-                )
+                if node_name:
+                    logger.error(
+                        f"Timeout while waiting for further output of task {task.task_id} (sync ironic for node {node_name})"
+                    )
+                else:
+                    logger.error(
+                        f"Timeout while waiting for further output of task {task.task_id} (sync ironic)"
+                    )
         else:
-            logger.info(
-                f"Task {task.task_id} (sync ironic) is running in background. No more output."
-            )
+            if node_name:
+                logger.info(
+                    f"Task {task.task_id} (sync ironic for node {node_name}) is running in background. No more output."
+                )
+            else:
+                logger.info(
+                    f"Task {task.task_id} (sync ironic) is running in background. No more output."
+                )
 
 
 class Sync(Command):