osism 0.20250616.0__py3-none-any.whl → 0.20250627.0__py3-none-any.whl

osism/api.py

@@ -79,27 +79,71 @@ baremetal_events = BaremetalEvents()
 
 @app.get("/")
 async def root():
-    return {"message": "Hello World"}
+    return {"result": "ok"}
 
 
-@app.post("/meters/sink")
+@app.get("/v1")
+async def v1():
+    return {"result": "ok"}
+
+
+@app.post("/v1/meters/sink")
 async def write_sink_meters(request: Request):
     data = await request.json()
 
 
-@app.post("/events/sink")
+@app.post("/v1/events/sink")
 async def write_sink_events(request: Request):
     data = await request.json()
 
 
-@app.post("/notifications/baremetal", status_code=204)
+@app.post("/v1/notifications/baremetal", status_code=204)
 async def notifications_baremetal(notification: NotificationBaremetal) -> None:
 
     handler = baremetal_events.get_handler(notification.event_type)
     handler(notification.payload)
 
 
-@app.post("/webhook/netbox", response_model=WebhookNetboxResponse, status_code=200)
+@app.post("/v1/switches/{identifier}/ztp/complete")
+async def switches_ztp_complete(identifier: str):
+    if not utils.nb:
+        return {"result": "netbox not enabled"}
+
+    device = None
+
+    # Search by device name
+    devices = utils.nb.dcim.devices.filter(name=identifier)
+    if devices:
+        device = devices[0]
+
+    # Search by inventory_hostname custom field
+    if not device:
+        devices = utils.nb.dcim.devices.filter(cf_inventory_hostname=identifier)
+        if devices:
+            device = devices[0]
+
+    # Search by serial number
+    if not device:
+        devices = utils.nb.dcim.devices.filter(serial=identifier)
+        if devices:
+            device = devices[0]
+
+    if device:
+        logger.info(
+            f"Found device {device.name} for ZTP complete with identifier {identifier}"
+        )
+
+        # Set provision_state custom field to active
+        device.custom_fields["provision_state"] = "active"
+        device.save()
+
+        return {"result": "ok", "device": device.name}
+    else:
+        logger.warning(f"No device found for ZTP complete with identifier {identifier}")
+        return {"result": "device not found"}
+
+
+@app.post("/v1/webhook/netbox", response_model=WebhookNetboxResponse, status_code=200)
 async def webhook(
     webhook_input: WebhookNetboxData,
     request: Request,

osism/commands/baremetal.py

@@ -131,20 +131,35 @@ class BaremetalDeploy(Command):
             if not node:
                 continue
 
-            if node.provision_state in ["available", "deploy failed"]:
+            if (
+                node.provision_state in ["available", "deploy failed"]
+                and not node["maintenance"]
+            ):
                 provision_state = "active"
             elif (
                 node.provision_state == "error"
                 or node.provision_state == "active"
+                and not node["maintenance"]
                 and rebuild
             ):
                 provision_state = "rebuild"
             else:
                 logger.warning(
-                    f"Node {node.name} ({node.id}) not in supported provision state"
+                    f"Node {node.name} ({node.id}) not in supported state! Provision state: {node.provision_state}, maintenance mode: {node['maintenance']}"
                 )
                 continue
 
+            # NOTE: Ironic removes "instance_info" on undeploy. It was saved to "extra" during sync and needs to be refreshed here.
+            if (
+                "instance_info" in node
+                and not node["instance_info"]
+                and "instance_info" in node["extra"]
+                and node["extra"]["instance_info"]
+            ):
+                node = conn.baremetal.update_node(
+                    node, instance_info=json.loads(node.extra["instance_info"])
+                )
+
             try:
                 conn.baremetal.validate_node(
                     node.id, required=("boot", "deploy", "power")
@@ -272,12 +287,17 @@ class BaremetalUndeploy(Command):
 
             if node.provision_state in ["active", "deploy failed", "error"]:
                 try:
-                    conn.baremetal.set_node_provision_state(node.id, "undeploy")
+                    node = conn.baremetal.set_node_provision_state(node.id, "undeploy")
                 except Exception as exc:
                     logger.warning(
                         f"Node {node.name} ({node.id}) could not be moved to available state: {exc}"
                     )
                     continue
+                # NOTE: Ironic removes "instance_info" on undeploy. It was saved to "extra" during sync and needs to be refreshed here.
+                if "instance_info" in node["extra"]:
+                    node = conn.baremetal.update_node(
+                        node, instance_info=json.loads(node.extra["instance_info"])
+                    )
             else:
                 logger.warning(
                     f"Node {node.name} ({node.id}) not in supported provision state"

osism/commands/manage.py

@@ -1,5 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
+import json
+import os
+from datetime import datetime
 from re import findall
 from urllib.parse import urljoin
 
@@ -7,10 +10,12 @@ from cliff.command import Command
 import docker
 from jinja2 import Template
 from loguru import logger
+import paramiko
 import requests
 
 from osism.data import TEMPLATE_IMAGE_CLUSTERAPI, TEMPLATE_IMAGE_OCTAVIA
-from osism.tasks import openstack, handle_task
+from osism.tasks import openstack, ansible, handle_task
+from osism import utils
 
 SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.31", "1.32", "1.33"]
 
@@ -360,3 +365,273 @@ class Flavors(Command):
             )
 
         return handle_task(task, wait, format="script", timeout=3600)
+
+
+class Dnsmasq(Command):
+    def get_parser(self, prog_name):
+        parser = super(Dnsmasq, self).get_parser(prog_name)
+        parser.add_argument(
+            "--no-wait",
+            default=False,
+            help="Do not wait until dnsmasq has been applied",
+            action="store_true",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        wait = not parsed_args.no_wait
+
+        task_signature = ansible.run.si("infrastructure", "dnsmasq", [])
+        task = task_signature.apply_async()
+        if wait:
+            logger.info(
+                f"It takes a moment until task {task.task_id} (dnsmasq) has been started and output is visible here."
+            )
+
+        return handle_task(task, wait, format="log", timeout=300)
+
+
+class Sonic(Command):
+    def get_parser(self, prog_name):
+        parser = super(Sonic, self).get_parser(prog_name)
+        parser.add_argument(
+            "hostname", type=str, help="Hostname of the SONiC switch to manage"
+        )
+        parser.add_argument(
+            "--reload",
+            action="store_true",
+            help="Execute config reload after config load to restart services",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        hostname = parsed_args.hostname
+        reload_config = parsed_args.reload
+        today = datetime.now().strftime("%Y%m%d")
+
+        try:
+            # Get device from NetBox - try by name first, then by inventory_hostname
+            device = utils.nb.dcim.devices.get(name=hostname)
+            if not device:
+                # Try to find by inventory_hostname custom field
+                devices = utils.nb.dcim.devices.filter(cf_inventory_hostname=hostname)
+                if devices:
+                    device = devices[0]  # Take the first match
+                    logger.info(f"Device found by inventory_hostname: {device.name}")
+                else:
+                    logger.error(
+                        f"Device {hostname} not found in NetBox (searched by name and inventory_hostname)"
+                    )
+                    return 1
+
+            # Get device configuration from local_context_data
+            if (
+                not hasattr(device, "local_context_data")
+                or not device.local_context_data
+            ):
+                logger.error(f"Device {hostname} has no local_context_data in NetBox")
+                return 1
+
+            config_context = device.local_context_data
+
+            # Save config context to local /tmp directory
+            config_context_file = f"/tmp/config_db_{hostname}_{today}.json"
+            try:
+                with open(config_context_file, "w") as f:
+                    json.dump(config_context, f, indent=2)
+                logger.info(f"Config context saved to {config_context_file}")
+            except Exception as e:
+                logger.error(f"Failed to save config context: {e}")
+                return 1
+
+            # Extract SSH connection details
+            ssh_host = None
+            ssh_username = None
+
+            # Try to get SSH details from config context
+            if "management" in config_context:
+                mgmt = config_context["management"]
+                if "ip" in mgmt:
+                    ssh_host = mgmt["ip"]
+                if "username" in mgmt:
+                    ssh_username = mgmt["username"]
+
+            # Fallback: try to get OOB IP from NetBox
+            if not ssh_host:
+                from osism.tasks.conductor.netbox import get_device_oob_ip
+
+                oob_result = get_device_oob_ip(device)
+                if oob_result:
+                    ssh_host = oob_result[0]
+
+            if not ssh_host:
+                logger.error(f"No SSH host found for device {hostname}")
+                return 1
+
+            if not ssh_username:
+                ssh_username = "admin"  # Default SONiC username
+
+            # SSH private key path
+            ssh_key_path = "/ansible/secrets/id_rsa.operator"
+
+            if not os.path.exists(ssh_key_path):
+                logger.error(f"SSH private key not found at {ssh_key_path}")
+                return 1
+
+            logger.info(
+                f"Connecting to {hostname} ({ssh_host}) to backup SONiC configuration"
+            )
+
+            # Create SSH connection
+            ssh = paramiko.SSHClient()
+            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+            try:
+                # Connect with private key
+                ssh.connect(
+                    hostname=ssh_host,
+                    username=ssh_username,
+                    key_filename=ssh_key_path,
+                    timeout=30,
+                )
+
+                # Generate backup filename with date and increment on switch
+                base_backup_path = f"/home/admin/config_db_{hostname}_{today}"
+                backup_filename = f"{base_backup_path}_1.json"
+
+                # Find next available filename on switch
+                x = 1
+                while True:
+                    check_cmd = f"ls {base_backup_path}_{x}.json 2>/dev/null"
+                    stdin, stdout, stderr = ssh.exec_command(check_cmd)
+                    if stdout.read().decode().strip() == "":
+                        backup_filename = f"{base_backup_path}_{x}.json"
+                        break
+                    x += 1
+
+                logger.info(
+                    f"Backing up current configuration on switch to {backup_filename}"
+                )
+
+                # Backup current configuration on switch
+                backup_cmd = f"sudo cp /etc/sonic/config_db.json {backup_filename}"
+                stdin, stdout, stderr = ssh.exec_command(backup_cmd)
+                exit_status = stdout.channel.recv_exit_status()
+
+                if exit_status != 0:
+                    error_msg = stderr.read().decode()
+                    logger.error(
+                        f"Failed to backup configuration on switch: {error_msg}"
+                    )
+                    return 1
+
+                logger.info("Configuration backed up successfully on switch")
+
+                # Upload local config context to switch /tmp directory
+                switch_config_file = f"/tmp/config_db_{hostname}_current.json"
+                logger.info(
+                    f"Uploading config context to {switch_config_file} on switch"
+                )
+
+                # Use SFTP to upload the config context file
+                sftp = ssh.open_sftp()
+                try:
+                    sftp.put(config_context_file, switch_config_file)
+                    logger.info(
+                        f"Config context successfully uploaded to {switch_config_file} on switch"
+                    )
+                except Exception as e:
+                    logger.error(f"Failed to upload config context to switch: {e}")
+                    return 1
+                finally:
+                    sftp.close()
+
+                # Load and apply the new configuration
+                logger.info("Loading and applying new configuration on switch")
+
+                load_cmd = f"sudo config load -y {switch_config_file}"
+                stdin, stdout, stderr = ssh.exec_command(load_cmd)
+                exit_status = stdout.channel.recv_exit_status()
+
+                if exit_status != 0:
+                    error_msg = stderr.read().decode()
+                    logger.error(f"Failed to load configuration: {error_msg}")
+                    return 1
+
+                logger.info("Configuration loaded and applied successfully")
+
+                # Optionally reload configuration to restart services
+                config_operations_successful = True
+                if reload_config:
+                    logger.info("Reloading configuration to restart services")
+
+                    reload_cmd = "sudo config reload -y"
+                    stdin, stdout, stderr = ssh.exec_command(reload_cmd)
+                    exit_status = stdout.channel.recv_exit_status()
+
+                    if exit_status != 0:
+                        error_msg = stderr.read().decode()
+                        logger.error(f"Failed to reload configuration: {error_msg}")
+                        config_operations_successful = False
+                    else:
+                        logger.info("Configuration reloaded successfully")
+
+                # Save configuration only if load (and optionally reload) were successful
+                if config_operations_successful:
+                    logger.info("Saving configuration to persist changes")
+
+                    save_cmd = "sudo config save -y"
+                    stdin, stdout, stderr = ssh.exec_command(save_cmd)
+                    exit_status = stdout.channel.recv_exit_status()
+
+                    if exit_status != 0:
+                        error_msg = stderr.read().decode()
+                        logger.error(f"Failed to save configuration: {error_msg}")
+                        return 1
+
+                    logger.info("Configuration saved successfully")
+                else:
+                    logger.warning("Skipping config save due to reload failure")
+
+                # Delete the temporary configuration file
+                logger.info(f"Cleaning up temporary file {switch_config_file}")
+
+                delete_cmd = f"rm {switch_config_file}"
+                stdin, stdout, stderr = ssh.exec_command(delete_cmd)
+                exit_status = stdout.channel.recv_exit_status()
+
+                if exit_status != 0:
+                    error_msg = stderr.read().decode()
+                    logger.warning(f"Failed to delete temporary file: {error_msg}")
+                else:
+                    logger.info("Temporary file deleted successfully")
+
+                logger.info("SONiC configuration management completed successfully")
+                logger.info(f"- Config context saved locally to: {config_context_file}")
+                if reload_config and config_operations_successful:
+                    logger.info("- Configuration loaded, reloaded, and saved on switch")
+                elif config_operations_successful:
+                    logger.info("- Configuration loaded and saved on switch")
+                else:
+                    logger.info(
+                        "- Configuration loaded on switch (save skipped due to reload failure)"
+                    )
+                logger.info(f"- Backup created on switch: {backup_filename}")
+
+                return 0
+
+            except paramiko.AuthenticationException:
+                logger.error(f"Authentication failed for {ssh_host}")
+                return 1
+            except paramiko.SSHException as e:
+                logger.error(f"SSH connection failed: {e}")
+                return 1
+            except Exception as e:
+                logger.error(f"Unexpected error during SSH operations: {e}")
+                return 1
+            finally:
+                ssh.close()
+
+        except Exception as e:
+            logger.error(f"Error managing SONiC device {hostname}: {e}")
+            return 1

osism/commands/reconciler.py

@@ -38,13 +38,20 @@ class Sync(Command):
             type=int,
             help="Timeout for a scheduled task that has not been executed yet",
         )
+        parser.add_argument(
+            "--flush-cache",
+            default=False,
+            help="Flush cache before running sync",
+            action="store_true",
+        )
         return parser
 
     def take_action(self, parsed_args):
         wait = not parsed_args.no_wait
         task_timeout = parsed_args.task_timeout
+        flush_cache = parsed_args.flush_cache
 
-        t = reconciler.run.delay(publish=wait)
+        t = reconciler.run.delay(publish=wait, flush_cache=flush_cache)
         if wait:
             logger.info(
                 f"Task {t.task_id} (sync inventory) is running in background. Output coming soon."

osism/commands/sync.py

@@ -23,24 +23,44 @@ class Facts(Command):
 class Sonic(Command):
     def get_parser(self, prog_name):
         parser = super(Sonic, self).get_parser(prog_name)
+        parser.add_argument(
+            "device",
+            nargs="?",
+            help="Optional device name to sync configuration for a specific device",
+        )
         parser.add_argument(
             "--no-wait",
             default=False,
             help="Do not wait until the sync has been completed",
             action="store_true",
         )
+        parser.add_argument(
+            "--diff",
+            default=True,
+            help="Show configuration diff when changes are detected (default: True)",
+            action="store_true",
+        )
+        parser.add_argument(
+            "--no-diff",
+            dest="diff",
+            help="Do not show configuration diff",
+            action="store_false",
+        )
         return parser
 
     def take_action(self, parsed_args):
         wait = not parsed_args.no_wait
+        device_name = parsed_args.device
+        show_diff = parsed_args.diff
+
+        task = conductor.sync_sonic.delay(device_name, show_diff)
 
-        task = conductor.sync_sonic.delay()
-        if wait:
+        if device_name:
             logger.info(
-                f"Task {task.task_id} (sync sonic) is running. Wait. No more output."
+                f"Task {task.task_id} (sync sonic for device {device_name}) started"
             )
-            task.wait(timeout=None, interval=0.5)
         else:
-            logger.info(
-                f"Task {task.task_id} (sync sonic) is running in background. No more output."
-            )
+            logger.info(f"Task {task.task_id} (sync sonic) started")
+
+        rc = handle_task(task, wait=wait)
+        return rc

osism/settings.py

@@ -49,6 +49,7 @@ NETBOX_FILTER_CONDUCTOR_SONIC = os.getenv(
 SONIC_EXPORT_DIR = os.getenv("SONIC_EXPORT_DIR", "/etc/sonic/export")
 SONIC_EXPORT_PREFIX = os.getenv("SONIC_EXPORT_PREFIX", "osism_")
 SONIC_EXPORT_SUFFIX = os.getenv("SONIC_EXPORT_SUFFIX", "_config_db.json")
+SONIC_EXPORT_IDENTIFIER = os.getenv("SONIC_EXPORT_IDENTIFIER", "serial-number")
 
 NETBOX_SECONDARIES = (
     os.getenv("NETBOX_SECONDARIES", read_secret("NETBOX_SECONDARIES")) or "[]"

osism/tasks/conductor/__init__.py

@@ -48,8 +48,8 @@ def sync_ironic(self, force_update=False):
 
 
 @app.task(bind=True, name="osism.tasks.conductor.sync_sonic")
-def sync_sonic(self):
-    return _sync_sonic()
+def sync_sonic(self, device_name=None, show_diff=True):
+    return _sync_sonic(device_name, self.request.id, show_diff)
 
 
 __all__ = [

osism/tasks/conductor/ironic.py

@@ -152,10 +152,14 @@ def sync_ironic(request_id, get_ironic_parameters, force_update=False):
                             .render(remote_board_address=oob_ip)
                         )
         node_attributes.update({"resource_class": device.name})
-        # NOTE: Write metadata used for provisioning into 'extra' field, so that
-        #       it is available during node deploy without querying the NetBox again
         if "extra" not in node_attributes:
             node_attributes["extra"] = {}
+        # NOTE: Copy instance_info into extra field. because ironic removes it on undeployment. This way it may be readded on undeploy without querying the netbox again
+        if "instance_info" in node_attributes and node_attributes["instance_info"]:
+            node_attributes["extra"].update(
+                {"instance_info": json.dumps(node_attributes["instance_info"])}
+            )
+        # NOTE: Write metadata used for provisioning into 'extra' field, so that it is available during node deploy without querying the netbox again
         if (
             "netplan_parameters" in device.custom_fields
             and device.custom_fields["netplan_parameters"]
@@ -231,23 +235,21 @@ def sync_ironic(request_id, get_ironic_parameters, force_update=False):
                     details=False, attributes=dict(node_uuid=node["uuid"])
                 )
                 # NOTE: Baremetal ports are only required for (i)pxe boot
-                if node["boot_interface"] in ["pxe", "ipxe"]:
-                    for port_attributes in ports_attributes:
-                        port_attributes.update({"node_id": node["uuid"]})
-                        port = [
-                            port
-                            for port in node_ports
-                            if port_attributes["address"].upper()
-                            == port["address"].upper()
-                        ]
-                        if not port:
-                            osism_utils.push_task_output(
-                                request_id,
-                                f"Creating baremetal port with MAC address {port_attributes['address']} for {device.name}\n",
-                            )
-                            openstack.baremetal_port_create(port_attributes)
-                        else:
-                            node_ports.remove(port[0])
+                for port_attributes in ports_attributes:
+                    port_attributes.update({"node_id": node["uuid"]})
+                    port = [
+                        port
+                        for port in node_ports
+                        if port_attributes["address"].upper() == port["address"].upper()
+                    ]
+                    if not port:
+                        osism_utils.push_task_output(
+                            request_id,
+                            f"Creating baremetal port with MAC address {port_attributes['address']} for {device.name}\n",
+                        )
+                        openstack.baremetal_port_create(port_attributes)
+                    else:
+                        node_ports.remove(port[0])
                 for node_port in node_ports:
                     # NOTE: Delete remaining ports not found in NetBox
                     osism_utils.push_task_output(

osism/tasks/conductor/sonic/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""SONiC configuration management package."""
+
+from .config_generator import generate_sonic_config
+from .exporter import save_config_to_netbox, export_config_to_file
+from .sync import sync_sonic
+from .connections import (
+    get_connected_interfaces,
+    get_connected_device_for_sonic_interface,
+    get_connected_device_via_interface,
+    find_interconnected_devices,
+    get_device_bgp_neighbors_via_loopback,
+)
+
+__all__ = [
+    "generate_sonic_config",
+    "save_config_to_netbox",
+    "export_config_to_file",
+    "sync_sonic",
+    "get_connected_interfaces",
+    "get_connected_device_for_sonic_interface",
+    "get_connected_device_via_interface",
+    "find_interconnected_devices",
+    "get_device_bgp_neighbors_via_loopback",
+]