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

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