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

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

@@ -10,7 +10,7 @@ from loguru import logger
 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
 
 SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.31", "1.32", "1.33"]
 
@@ -360,3 +360,27 @@ 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)

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"]

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",
+]

osism/tasks/conductor/sonic/bgp.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""BGP and AS calculation functions for SONiC configuration."""
+
+from loguru import logger
+
+from .constants import DEFAULT_LOCAL_AS_PREFIX
+
+
+def calculate_local_asn_from_ipv4(
+    ipv4_address: str, prefix: int = DEFAULT_LOCAL_AS_PREFIX
+) -> int:
+    """Calculate AS number from IPv4 address.
+
+    Args:
+        ipv4_address: IPv4 address in format "192.168.45.123/32" or "192.168.45.123"
+        prefix: Four-digit prefix for AS number (default: 4200)
+
+    Returns:
+        AS number calculated as prefix + 3rd octet (padded) + 4th octet (padded)
+        Example: 192.168.45.123 with prefix 4200 -> 4200045123
+
+    Raises:
+        ValueError: If IP address format is invalid
+    """
+    try:
+        # Remove CIDR notation if present
+        ip_only = ipv4_address.split("/")[0]
+        octets = ip_only.split(".")
+
+        if len(octets) != 4:
+            raise ValueError(f"Invalid IPv4 address format: {ipv4_address}")
+
+        # AS = prefix + third octet (3 digits) + fourth octet (3 digits)
+        # Example: 192.168.45.123 -> 4200 + 045 + 123 = 4200045123
+        third_octet = int(octets[2])
+        fourth_octet = int(octets[3])
+
+        if not (0 <= third_octet <= 255 and 0 <= fourth_octet <= 255):
+            raise ValueError(f"Invalid octet values in: {ipv4_address}")
+
+        return int(f"{prefix}{third_octet:03d}{fourth_octet:03d}")
+    except (IndexError, ValueError) as e:
+        raise ValueError(f"Failed to calculate AS from {ipv4_address}: {str(e)}")
+
+
+# Deprecated: Use connections.find_interconnected_devices instead
+# This function is kept for backward compatibility but delegates to the new module
+def find_interconnected_spine_groups(devices, target_roles=["spine", "superspine"]):
+    """Find groups of interconnected spine/superspine switches.
+
+    Args:
+        devices: List of NetBox device objects
+        target_roles: List of device roles to consider (default: ["spine", "superspine"])
+
+    Returns:
+        List of groups, where each group is a list of interconnected devices of the same role
+    """
+    # Import here to avoid circular imports
+    from .connections import find_interconnected_devices
+
+    return find_interconnected_devices(devices, target_roles)
+
+
+def calculate_minimum_as_for_group(device_group, prefix=DEFAULT_LOCAL_AS_PREFIX):
+    """Calculate the minimum AS number for a group of interconnected devices.
+
+    Args:
+        device_group: List of interconnected devices
+        prefix: AS prefix (default: DEFAULT_LOCAL_AS_PREFIX)
+
+    Returns:
+        int: Minimum AS number for the group, or None if no valid AS can be calculated
+    """
+    as_numbers = []
+
+    for device in device_group:
+        if device.primary_ip4:
+            try:
+                as_number = calculate_local_asn_from_ipv4(
+                    str(device.primary_ip4), prefix
+                )
+                as_numbers.append(as_number)
+            except ValueError as e:
+                logger.debug(f"Could not calculate AS for device {device.name}: {e}")
+
+    return min(as_numbers) if as_numbers else None

osism/tasks/conductor/sonic/cache.py

@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""Interface caching for SONiC configuration generation."""
+
+import threading
+from typing import Dict, List, Optional
+from loguru import logger
+
+from osism import utils
+
+
+class InterfaceCache:
+    """Thread-local cache for device interfaces during sync_sonic task."""
+
+    def __init__(self):
+        self._cache: Dict[int, List] = {}
+        self._lock = threading.Lock()
+
+    def get_device_interfaces(self, device_id: int) -> List:
+        """Get interfaces for a device, using cache if available.
+
+        Args:
+            device_id: NetBox device ID
+
+        Returns:
+            List of interface objects
+        """
+        with self._lock:
+            if device_id not in self._cache:
+                logger.debug(f"Fetching interfaces for device {device_id}")
+                try:
+                    interfaces = list(
+                        utils.nb.dcim.interfaces.filter(device_id=device_id)
+                    )
+                    self._cache[device_id] = interfaces
+                    logger.debug(
+                        f"Cached {len(interfaces)} interfaces for device {device_id}"
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to fetch interfaces for device {device_id}: {e}"
+                    )
+                    self._cache[device_id] = []
+            else:
+                logger.debug(f"Using cached interfaces for device {device_id}")
+
+            return self._cache[device_id]
+
+    def clear(self):
+        """Clear the cache."""
+        with self._lock:
+            cache_size = len(self._cache)
+            self._cache.clear()
+            logger.debug(f"Cleared interface cache ({cache_size} devices)")
+
+    def get_cache_stats(self) -> Dict[str, int]:
+        """Get cache statistics.
+
+        Returns:
+            Dictionary with cache statistics
+        """
+        with self._lock:
+            total_interfaces = sum(
+                len(interfaces) for interfaces in self._cache.values()
+            )
+            return {
+                "cached_devices": len(self._cache),
+                "total_interfaces": total_interfaces,
+            }
+
+
+# Thread-local storage for the interface cache
+_thread_local = threading.local()
+
+
+def get_interface_cache() -> InterfaceCache:
+    """Get the current thread's interface cache.
+
+    Returns:
+        InterfaceCache instance for current thread
+    """
+    if not hasattr(_thread_local, "interface_cache"):
+        _thread_local.interface_cache = InterfaceCache()
+    return _thread_local.interface_cache
+
+
+def get_cached_device_interfaces(device_id: int) -> List:
+    """Get interfaces for a device using the thread-local cache.
+
+    Args:
+        device_id: NetBox device ID
+
+    Returns:
+        List of interface objects
+    """
+    cache = get_interface_cache()
+    return cache.get_device_interfaces(device_id)
+
+
+def clear_interface_cache():
+    """Clear the current thread's interface cache."""
+    if hasattr(_thread_local, "interface_cache"):
+        _thread_local.interface_cache.clear()
+
+
+def get_interface_cache_stats() -> Optional[Dict[str, int]]:
+    """Get cache statistics for the current thread.
+
+    Returns:
+        Dictionary with cache statistics or None if no cache exists
+    """
+    if hasattr(_thread_local, "interface_cache"):
+        return _thread_local.interface_cache.get_cache_stats()
+    return None