osism 0.20250621.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/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, ansible, handle_task
+from osism import utils
 
 SUPPORTED_CLUSTERAPI_K8S_IMAGES = ["1.31", "1.32", "1.33"]
 
@@ -384,3 +389,249 @@ class Dnsmasq(Command):
             )
 
         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/tasks/conductor/ironic.py

@@ -235,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/config_generator.py

@@ -29,7 +29,6 @@ from .interface import (
 from .connections import (
     get_connected_interfaces,
     get_connected_device_for_sonic_interface,
-    get_device_bgp_neighbors_via_loopback,
 )
 from .cache import get_cached_device_interfaces
 
@@ -305,7 +304,7 @@ def _add_port_configurations(
         interface_speed = int(port_speed) if port_speed else None
         is_breakout_port = port_name in breakout_info["breakout_ports"]
         correct_alias = convert_sonic_interface_to_alias(
-            port_name, interface_speed, is_breakout_port
+            port_name, interface_speed, is_breakout_port, port_config
         )
 
         # Use master port index for breakout ports
@@ -457,7 +456,7 @@ def _add_missing_breakout_ports(
             # Generate correct alias (breakout port always gets subport notation)
             interface_speed = int(port_speed)
             correct_alias = convert_sonic_interface_to_alias(
-                port_name, interface_speed, is_breakout=True
+                port_name, interface_speed, is_breakout=True, port_config=port_config
             )
 
             # Use master port index for breakout ports
@@ -608,11 +607,6 @@ def _add_bgp_configurations(
             "v6only": "true",
         }
 
-    # Add additional BGP_NEIGHBOR configuration using Loopback0 IP addresses
-    _add_loopback_bgp_neighbors(
-        config, device, portchannel_info, connected_interfaces, device_as_mapping
-    )
-
 
 def _get_connected_device_for_interface(device, interface_name):
     """Get the connected device for a given interface name.
@@ -652,10 +646,40 @@ def _determine_peer_type(local_device, connected_device, device_as_mapping=None)
         connected_as = None
         if device_as_mapping and connected_device.id in device_as_mapping:
             connected_as = device_as_mapping[connected_device.id]
-        elif connected_device.primary_ip4:
-            connected_as = calculate_local_asn_from_ipv4(
-                str(connected_device.primary_ip4.address)
-            )
+        else:
+            # If connected device is not in device_as_mapping, check if it's a spine/superspine
+            # and calculate AS for its group
+            if connected_device.role and connected_device.role.slug in [
+                "spine",
+                "superspine",
+            ]:
+                # Import here to avoid circular imports
+                from .bgp import calculate_minimum_as_for_group
+                from .connections import find_interconnected_devices
+
+                # Get all devices to find the group
+                all_devices = list(
+                    utils.nb.dcim.devices.filter(role=["spine", "superspine"])
+                )
+                spine_groups = find_interconnected_devices(
+                    all_devices, ["spine", "superspine"]
+                )
+
+                # Find which group the connected device belongs to
+                for group in spine_groups:
+                    if any(dev.id == connected_device.id for dev in group):
+                        connected_as = calculate_minimum_as_for_group(group)
+                        if connected_as:
+                            logger.debug(
+                                f"Calculated AS {connected_as} for connected spine/superspine device {connected_device.name}"
+                            )
+                        break
+
+            # Fallback to calculating from IPv4 if still no AS
+            if not connected_as and connected_device.primary_ip4:
+                connected_as = calculate_local_asn_from_ipv4(
+                    str(connected_device.primary_ip4.address)
+                )
 
         # Compare AS numbers
         if local_as and connected_as and local_as == connected_as:
@@ -670,30 +694,91 @@ def _determine_peer_type(local_device, connected_device, device_as_mapping=None)
         return "external"  # Default to external on error
 
 
-def _add_loopback_bgp_neighbors(
-    config, device, portchannel_info, connected_interfaces, device_as_mapping=None
-):
-    """Add BGP_NEIGHBOR configuration using Loopback0 IP addresses from connected devices."""
+def _get_ntp_server_for_device(device):
+    """Get single NTP server IP for a SONiC device based on OOB connection to metalbox.
+
+    Returns the IP address of the metalbox device interface that is connected to the
+    OOB switch. If VLANs are used, returns the IP of the VLAN interface where the
+    SONiC switch management interface (eth0) has access.
+
+    Args:
+        device: SONiC device object
+
+    Returns:
+        str: IP address of the NTP server or None if not found
+    """
     try:
-        # Get BGP neighbors via loopback using the new connections module
-        bgp_neighbors = get_device_bgp_neighbors_via_loopback(
-            device, portchannel_info, connected_interfaces, config["PORT"]
-        )
+        # Get the OOB IP configuration for this SONiC device
+        oob_ip_result = get_device_oob_ip(device)
+        if not oob_ip_result:
+            logger.debug(f"No OOB IP found for device {device.name}")
+            return None
 
-        for neighbor_info in bgp_neighbors:
-            neighbor_key = f"default|{neighbor_info['ip']}"
+        oob_ip, prefix_len = oob_ip_result
+        logger.debug(f"Device {device.name} has OOB IP {oob_ip}/{prefix_len}")
 
-            # Determine peer_type based on AS comparison
-            peer_type = _determine_peer_type(
-                device,
-                neighbor_info["device"],
-                device_as_mapping,
-            )
+        # Find the network/subnet that contains this OOB IP
+        from ipaddress import IPv4Network, IPv4Address
+
+        device_network = IPv4Network(f"{oob_ip}/{prefix_len}", strict=False)
 
-            config["BGP_NEIGHBOR"][neighbor_key] = {"peer_type": peer_type}
+        # Get all metalbox devices
+        metalbox_devices = utils.nb.dcim.devices.filter(role="metalbox")
+
+        for metalbox in metalbox_devices:
+            logger.debug(f"Checking metalbox device {metalbox.name} for NTP server")
+
+            # Get all interfaces on this metalbox
+            interfaces = utils.nb.dcim.interfaces.filter(device_id=metalbox.id)
+
+            for interface in interfaces:
+                # Skip management-only interfaces
+                if hasattr(interface, "mgmt_only") and interface.mgmt_only:
+                    continue
+
+                # Check both physical interfaces and VLAN interfaces (SVIs)
+                # VLAN interfaces are typically named "Vlan123" for VLAN ID 123
+                is_vlan_interface = (
+                    hasattr(interface, "type")
+                    and interface.type
+                    and interface.type.value == "virtual"
+                    and interface.name.startswith("Vlan")
+                )
+
+                # Get IP addresses for this interface
+                ip_addresses = utils.nb.ipam.ip_addresses.filter(
+                    assigned_object_id=interface.id,
+                )
+
+                for ip_addr in ip_addresses:
+                    if ip_addr.address:
+                        # Extract IP address without prefix
+                        ip_only = ip_addr.address.split("/")[0]
+
+                        # Check if it's IPv4 and in the same network as the SONiC device
+                        try:
+                            metalbox_ip = IPv4Address(ip_only)
+                            if metalbox_ip in device_network:
+                                interface_type = (
+                                    "VLAN interface"
+                                    if is_vlan_interface
+                                    else "interface"
+                                )
+                                logger.info(
+                                    f"Found NTP server {ip_only} on metalbox {metalbox.name} "
+                                    f"{interface_type} {interface.name} for SONiC device {device.name}"
+                                )
+                                return ip_only
+                        except ValueError:
+                            # Skip non-IPv4 addresses
+                            continue
+
+        logger.warning(f"No suitable NTP server found for SONiC device {device.name}")
+        return None
 
     except Exception as e:
-        logger.warning(f"Could not process BGP neighbors for device {device.name}: {e}")
+        logger.warning(f"Could not determine NTP server for device {device.name}: {e}")
+        return None
 
 
 def _get_ntp_servers():
@@ -755,20 +840,27 @@ def _get_ntp_servers():
 
 
 def _add_ntp_configuration(config, device):
-    """Add NTP_SERVER configuration to device config."""
-    try:
-        ntp_servers = _get_ntp_servers()
+    """Add NTP_SERVER configuration to device config.
 
-        # Add NTP servers to this device's configuration
-        for ip, ntp_config in ntp_servers.items():
-            config["NTP_SERVER"][ip] = copy.deepcopy(ntp_config)
-
-        if ntp_servers:
-            logger.debug(
-                f"Added {len(ntp_servers)} NTP servers to device {device.name}"
+    Each SONiC switch gets exactly one NTP server - the IP address of the
+    metalbox device interface connected to the OOB switch.
+    """
+    try:
+        # Get the specific NTP server for this device
+        ntp_server_ip = _get_ntp_server_for_device(device)
+
+        if ntp_server_ip:
+            # Add single NTP server configuration
+            config["NTP_SERVER"][ntp_server_ip] = {
+                "maxpoll": "10",
+                "minpoll": "6",
+                "prefer": "false",
+            }
+            logger.info(
+                f"Added NTP server {ntp_server_ip} to SONiC device {device.name}"
             )
         else:
-            logger.debug(f"No NTP servers found for device {device.name}")
+            logger.warning(f"No NTP server found for SONiC device {device.name}")
 
     except Exception as e:
         logger.warning(f"Could not add NTP configuration to device {device.name}: {e}")

osism/tasks/conductor/sonic/constants.py

@@ -71,6 +71,7 @@ PORT_CONFIG_PATH = "/etc/sonic/port_config"
 
 # List of supported HWSKUs
 SUPPORTED_HWSKUS = [
+    "Accton-AS4625-54T",
     "Accton-AS5835-54T",
     "Accton-AS5835-54X",
     "Accton-AS7326-56X",

osism/tasks/conductor/sonic/interface.py

@@ -237,23 +237,43 @@ def _find_sonic_name_by_alias_mapping(interface_name, port_config):
     - tenGigE1 alias maps to Eth1/1/1 or Eth1/1
     - tenGigE48 alias maps to Eth1/48/1 or Eth1/48
     - hundredGigE49 alias maps to Eth1/49/1 or Eth1/49
+    - Eth1(Port1) -> Ethernet0, Eth2(Port2) -> Ethernet1, Eth3(Port) -> Ethernet2
 
     Args:
-        interface_name: NetBox interface name (e.g., "Eth1/1" or "Eth1/1/1")
+        interface_name: NetBox interface name (e.g., "Eth1/1", "Eth1/1/1", or "Eth1(Port1)")
         port_config: Port configuration dictionary
 
     Returns:
         str: SONiC interface name or original name if not found
     """
+    logger.debug(f"Finding SONiC name for interface: '{interface_name}'")
+    logger.debug(f"Port config contains {len(port_config)} entries")
+
+    # Handle new Eth1(Port1) format first
+    paren_match = re.match(r"Eth(\d+)\(Port(\d*)\)", interface_name)
+    if paren_match:
+        eth_num = int(paren_match.group(1))
+        # Map EthX(PortY) to EthernetX-1 (1-based to 0-based conversion)
+        ethernet_num = eth_num - 1
+        sonic_name = f"Ethernet{ethernet_num}"
+        logger.debug(
+            f"Alias mapping: {interface_name} -> {sonic_name} via Eth(Port) format (eth_num={eth_num}, ethernet_num={ethernet_num})"
+        )
+        return sonic_name
+
     # Create reverse mapping: expected NetBox name -> alias -> SONiC name
     for sonic_port, config in port_config.items():
         alias = config.get("alias", "")
         if not alias:
+            logger.debug(f"Skipping {sonic_port}: no alias")
             continue
 
         # Extract number from alias (e.g., tenGigE1 -> 1, hundredGigE49 -> 49)
         alias_match = re.search(r"(\d+)$", alias)
         if not alias_match:
+            logger.debug(
+                f"Skipping {sonic_port}: alias '{alias}' has no trailing number"
+            )
             continue
 
         alias_num = int(alias_match.group(1))
@@ -264,18 +284,25 @@ def _find_sonic_name_by_alias_mapping(interface_name, port_config):
             f"Eth1/{alias_num}/1",  # Breakout format (first subport)
         ]
 
+        logger.debug(
+            f"Checking {sonic_port} (alias='{alias}', alias_num={alias_num}) against expected_names: {expected_names}"
+        )
+
         if interface_name in expected_names:
             logger.debug(
                 f"Alias mapping: {interface_name} -> {sonic_port} via alias {alias}"
             )
             return sonic_port
 
-    logger.warning(f"No alias mapping found for {interface_name}")
+    logger.warning(f"No alias mapping found for '{interface_name}'")
+    logger.debug(
+        f"Available aliases in port_config: {[(sonic_port, config.get('alias', '')) for sonic_port, config in port_config.items()]}"
+    )
     return interface_name
 
 
 def convert_sonic_interface_to_alias(
-    sonic_interface_name, interface_speed=None, is_breakout=False
+    sonic_interface_name, interface_speed=None, is_breakout=False, port_config=None
 ):
     """Convert SONiC interface name to NetBox-style alias.
 
@@ -283,28 +310,134 @@ def convert_sonic_interface_to_alias(
         sonic_interface_name: SONiC interface name (e.g., "Ethernet0", "Ethernet4")
         interface_speed: Interface speed in Mbps (optional, for speed-based calculation)
         is_breakout: Whether this is a breakout port (adds subport notation)
+        port_config: Port configuration dictionary (optional, for alias-based calculation)
 
     Returns:
         str: NetBox-style alias (e.g., "Eth1/1", "Eth1/2" or "Eth1/1/1", "Eth1/1/2" for breakout)
 
     Examples:
-        - Regular 100G ports: Ethernet0 -> Eth1/1, Ethernet4 -> Eth1/2, Ethernet8 -> Eth1/3
-        - Regular other speeds: Ethernet0 -> Eth1/1, Ethernet1 -> Eth1/2, Ethernet2 -> Eth1/3
-        - Breakout ports: Ethernet0 -> Eth1/1/1, Ethernet1 -> Eth1/1/2, Ethernet2 -> Eth1/1/3, Ethernet3 -> Eth1/1/4
+        - Regular ports: Ethernet0 with alias "twentyFiveGigE1" -> Eth1/1
+        - Breakout ports: Ethernet2 with base port alias "twentyFiveGigE1" -> Eth1/1/3
     """
+    logger.debug(
+        f"Converting SONiC interface to alias: {sonic_interface_name}, speed={interface_speed}, is_breakout={is_breakout}"
+    )
+
     # Extract port number from SONiC format (Ethernet0, Ethernet4, etc.)
     match = re.match(r"Ethernet(\d+)", sonic_interface_name)
     if not match:
         # If it doesn't match expected pattern, return as-is
+        logger.debug(
+            f"Interface {sonic_interface_name} doesn't match Ethernet pattern, returning as-is"
+        )
         return sonic_interface_name
 
-    sonic_port_number = int(match.group(1))
+    ethernet_num = int(match.group(1))
+    logger.debug(f"Extracted ethernet_num: {ethernet_num}")
+
+    # If port_config is provided, use alias-based calculation
+    if port_config:
+        return _convert_using_port_config(
+            sonic_interface_name, ethernet_num, is_breakout, port_config
+        )
+
+    # Fallback to legacy speed-based calculation
+    return _convert_using_speed_calculation(ethernet_num, interface_speed, is_breakout)
+
+
+def _convert_using_port_config(
+    sonic_interface_name, ethernet_num, is_breakout, port_config
+):
+    """Convert using port config alias information."""
+    if is_breakout:
+        # For breakout ports, find the base port in port_config
+        base_port_name = _find_base_port_for_breakout(ethernet_num, port_config)
+        if base_port_name and base_port_name in port_config:
+            base_alias = port_config[base_port_name].get("alias", "")
+            # Extract port number from base alias
+            sonic_port_number = _extract_port_number_from_alias(base_alias)
+            if sonic_port_number is not None:
+                # Calculate subport number: how many ports after the base port
+                base_ethernet_num = int(base_port_name.replace("Ethernet", ""))
+                subport = (ethernet_num - base_ethernet_num) + 1
+
+                module = 1
+                result = f"Eth{module}/{sonic_port_number}/{subport}"
+                logger.debug(
+                    f"Breakout conversion using port config: {sonic_interface_name} -> {result} "
+                    f"(base_port={base_port_name}, base_alias={base_alias}, sonic_port_number={sonic_port_number}, subport={subport})"
+                )
+                return result
+
+        # Fallback if base port not found
+        logger.warning(
+            f"Could not find base port for breakout interface {sonic_interface_name}"
+        )
+        return _convert_using_speed_calculation(ethernet_num, None, is_breakout)
+    else:
+        # For regular ports, get alias directly
+        if sonic_interface_name in port_config:
+            alias = port_config[sonic_interface_name].get("alias", "")
+            sonic_port_number = _extract_port_number_from_alias(alias)
+            if sonic_port_number is not None:
+                module = 1
+                result = f"Eth{module}/{sonic_port_number}"
+                logger.debug(
+                    f"Regular conversion using port config: {sonic_interface_name} -> {result} "
+                    f"(alias={alias}, sonic_port_number={sonic_port_number})"
+                )
+                return result
+
+        # Fallback if not in port config
+        logger.warning(f"Interface {sonic_interface_name} not found in port config")
+        return _convert_using_speed_calculation(ethernet_num, None, is_breakout)
+
+
+def _find_base_port_for_breakout(ethernet_num, port_config):
+    """Find the base port for a breakout interface.
+
+    The base port is the next smaller or equal port that exists in port_config.
+    E.g., for Ethernet2 -> check Ethernet2, Ethernet1, Ethernet0 until found.
+    """
+    for base_num in range(ethernet_num, -1, -1):
+        base_port_name = f"Ethernet{base_num}"
+        if base_port_name in port_config:
+            logger.debug(
+                f"Found base port {base_port_name} for breakout interface Ethernet{ethernet_num}"
+            )
+            return base_port_name
+
+    logger.warning(f"No base port found for breakout interface Ethernet{ethernet_num}")
+    return None
+
+
+def _extract_port_number_from_alias(alias):
+    """Extract the port number from the end of an alias.
+
+    E.g., "twentyFiveGigE1" -> 1, "hundredGigE49" -> 49
+    """
+    if not alias:
+        return None
+
+    match = re.search(r"(\d+)$", alias)
+    if match:
+        port_number = int(match.group(1))
+        logger.debug(f"Extracted port number {port_number} from alias '{alias}'")
+        return port_number
+
+    logger.warning(f"Could not extract port number from alias '{alias}'")
+    return None
+
+
+def _convert_using_speed_calculation(ethernet_num, interface_speed, is_breakout):
+    """Legacy speed-based conversion (fallback)."""
+    logger.debug(f"Using legacy speed-based calculation for Ethernet{ethernet_num}")
 
     if is_breakout:
         # For breakout ports: Ethernet0 -> Eth1/1/1, Ethernet1 -> Eth1/1/2, etc.
         # Calculate base port (master port) and subport number
-        base_port = (sonic_port_number // 4) * 4  # Get base port (0, 4, 8, 12, ...)
-        subport = (sonic_port_number % 4) + 1  # Get subport number (1, 2, 3, 4)
+        base_port = (ethernet_num // 4) * 4  # Get base port (0, 4, 8, 12, ...)
+        subport = (ethernet_num % 4) + 1  # Get subport number (1, 2, 3, 4)
 
         # Calculate physical port number for the base port
         physical_port = (base_port // 4) + 1  # Convert to 1-based indexing
@@ -312,7 +445,11 @@ def convert_sonic_interface_to_alias(
         # Assume module 1 for now - could be extended for multi-module systems
         module = 1
 
-        return f"Eth{module}/{physical_port}/{subport}"
+        result = f"Eth{module}/{physical_port}/{subport}"
+        logger.debug(
+            f"Breakout conversion: base_port={base_port}, subport={subport}, physical_port={physical_port}, result={result}"
+        )
+        return result
     else:
         # For regular ports: use speed-based calculation
         # Determine speed category and multiplier
@@ -323,15 +460,21 @@ def convert_sonic_interface_to_alias(
             # Default for 1G, 10G, 25G ports - sequential numbering
             multiplier = 1
 
+        logger.debug(
+            f"Regular port calculation: interface_speed={interface_speed}, in_high_speed={interface_speed in HIGH_SPEED_PORTS if interface_speed else False}, multiplier={multiplier}"
+        )
+
         # Calculate physical port number
-        physical_port = (
-            sonic_port_number // multiplier
-        ) + 1  # Convert to 1-based indexing
+        physical_port = (ethernet_num // multiplier) + 1  # Convert to 1-based indexing
 
         # Assume module 1 for now - could be extended for multi-module systems
         module = 1
 
-        return f"Eth{module}/{physical_port}"
+        result = f"Eth{module}/{physical_port}"
+        logger.debug(
+            f"Regular conversion: ethernet_num={ethernet_num}, physical_port={physical_port}, result={result}"
+        )
+        return result
 
 
 def get_port_config(hwsku):
@@ -558,9 +701,14 @@ def detect_breakout_ports(device):
                                     )
                                     continue
 
+                                # Calculate physical port number (1/1 -> port 1, 1/2 -> port 2, etc.)
+                                physical_port_num = f"{module}/{port}"
+
                                 # Add breakout config for master port
                                 breakout_cfgs[master_port] = {
+                                    "breakout_owner": "MANUAL",
                                     "brkout_mode": brkout_mode,
+                                    "port": physical_port_num,
                                 }
 
                                 # Add all subports to breakout_ports
@@ -634,12 +782,15 @@ def detect_breakout_ports(device):
                     else:
                         continue  # Skip unsupported speeds
 
-                    # Calculate physical port number
-                    physical_port_num = (base_port // 4) + 1
+                    # Calculate physical port number (Ethernet0-3 -> port 1/1, Ethernet4-7 -> port 1/2, etc.)
+                    physical_port_index = (base_port // 4) + 1
+                    physical_port_num = f"1/{physical_port_index}"
 
                     # Add breakout config for master port
                     breakout_cfgs[master_port] = {
+                        "breakout_owner": "MANUAL",
                         "brkout_mode": brkout_mode,
+                        "port": physical_port_num,
                     }
 
                     # Add all ports to breakout_ports

osism/tasks/conductor/sonic/sync.py

@@ -82,7 +82,32 @@ def sync_sonic(device_name=None, task_id=None, show_diff=True):
     logger.info(f"Found {len(devices)} devices matching criteria")
 
     # Find interconnected spine/superspine groups for special AS calculation
-    spine_groups = find_interconnected_devices(devices, ["spine", "superspine"])
+    # When processing a single device, we need to consider all spine/superspine devices
+    # to properly detect interconnected groups, not just the requested device
+    if device_name and devices:
+        # Check if the single device is a spine/superspine
+        target_device = devices[0]
+        if target_device.role and target_device.role.slug in ["spine", "superspine"]:
+            # Fetch ALL spine/superspine devices to properly detect groups
+            logger.debug(
+                "Single spine/superspine device detected, fetching all spine/superspine devices for group detection"
+            )
+            all_spine_devices = []
+            nb_device_query_list = get_nb_device_query_list_sonic()
+            for nb_device_query in nb_device_query_list:
+                for device in utils.nb.dcim.devices.filter(**nb_device_query):
+                    if device.role and device.role.slug in ["spine", "superspine"]:
+                        all_spine_devices.append(device)
+            spine_groups = find_interconnected_devices(
+                all_spine_devices, ["spine", "superspine"]
+            )
+        else:
+            # For non-spine devices, use the original logic
+            spine_groups = find_interconnected_devices(devices, ["spine", "superspine"])
+    else:
+        # For multi-device processing, use the original logic
+        spine_groups = find_interconnected_devices(devices, ["spine", "superspine"])
+
     logger.info(f"Found {len(spine_groups)} interconnected spine/superspine groups")
 
     # Create mapping from device ID to its assigned AS number

osism/tasks/reconciler.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import io
+import os
 import subprocess
 
 from celery import Celery
@@ -27,7 +28,7 @@ def setup_periodic_tasks(sender, **kwargs):
 
 
 @app.task(bind=True, name="osism.tasks.reconciler.run")
-def run(self, publish=True):
+def run(self, publish=True, flush_cache=False):
     lock = Redlock(
         key="lock_osism_tasks_reconciler_run",
         masters={utils.redis},
@@ -36,8 +37,17 @@ def run(self, publish=True):
 
     if lock.acquire(timeout=20):
         logger.info("RUN /run.sh")
+
+        env = os.environ.copy()
+        if flush_cache:
+            env["FLUSH_CACHE"] = "true"
+
         p = subprocess.Popen(
-            "/run.sh", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+            "/run.sh",
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            env=env,
         )
 
         if publish:

{osism-0.20250621.0.dist-info → osism-0.20250627.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osism
-Version: 0.20250621.0
+Version: 0.20250627.0
 Summary: OSISM manager interface
 Home-page: https://github.com/osism/python-osism
 Author: OSISM GmbH
@@ -32,7 +32,7 @@ Requires-Dist: cliff==4.10.0
 Requires-Dist: deepdiff==8.5.0
 Requires-Dist: docker==7.1.0
 Requires-Dist: dtrack-auditor==1.5.0
-Requires-Dist: fastapi==0.115.13
+Requires-Dist: fastapi==0.115.14
 Requires-Dist: flower==2.0.1
 Requires-Dist: hiredis==3.2.1
 Requires-Dist: jc==1.25.5
@@ -41,8 +41,8 @@ Requires-Dist: kombu==5.5.4
 Requires-Dist: kubernetes==33.1.0
 Requires-Dist: loguru==0.7.3
 Requires-Dist: nbcli==0.10.0.dev2
-Requires-Dist: netmiko==4.5.0
 Requires-Dist: openstacksdk==4.6.0
+Requires-Dist: paramiko==3.5.1
 Requires-Dist: pottery==3.0.1
 Requires-Dist: prompt-toolkit==3.0.51
 Requires-Dist: pynetbox==7.5.0

{osism-0.20250621.0.dist-info → osism-0.20250627.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 osism/__init__.py,sha256=1UiNTBus0V0f2AbZQzAtVtu6zkfCCrw0OTq--NwFAqY,341
 osism/__main__.py,sha256=ILe4gu61xEISiBsxanqTQIdSkV-YhpZXTRlguCYyssk,141
-osism/api.py,sha256=t3HebSzk6fyY7bLJD9P95oEL1qWYXzpX6Yk1o_nVkMo,4356
+osism/api.py,sha256=cvFLczibM6Hrc3KWDNN4daUauyLF7zpuU1jll-5ywPI,5585
 osism/main.py,sha256=Dt2-9sLXcS-Ny4DAz7hrha-KRc7zd7BFUTRdfs_X8z4,893
 osism/settings.py,sha256=bebPBT6Hd1-KhJfwZdFR-s8eMwV4B1IFr-WrQBkOrWw,1786
 osism/actions/__init__.py,sha256=bG7Ffen4LvQtgnYPFEpFccsWs81t4zqqeqn9ZeirH6E,38
@@ -14,10 +14,10 @@ osism/commands/console.py,sha256=8BPz1hio5Wi6kONVAWFuSqkDRrMcLEYeFIY8dbtN6e4,321
 osism/commands/container.py,sha256=Fku2GaCM3Idq_FxExUtNqjrEM0XYjpVvXmueSVO8S_c,1601
 osism/commands/get.py,sha256=ryytjtXWmlMV0NucP5tGkMZu0nIlC4xVtjRk4iMZ06c,8967
 osism/commands/log.py,sha256=2IpYuosC7FZwwLvM8HmKSU1NRNIelVVYzqjjVMCrOJk,4072
-osism/commands/manage.py,sha256=FaO9dbYjNHYanS98-zC498bx26oU8E3loxCczH9mfKI,12751
+osism/commands/manage.py,sha256=uzfmt3R0PJ4HxUw_V945pN0FbKb3zhyiBuD9br1ORYE,23149
 osism/commands/netbox.py,sha256=e65P0kWrjTLw2T9HZthxjDTIRa-KAHgSSJAlvVef7n4,7345
 osism/commands/noset.py,sha256=7zDFuFMyNpo7DUOKcNiYV8nodtdMOYFp5LDPcuJhlZ8,1481
-osism/commands/reconciler.py,sha256=jy07Qbl219e-WCtWbtV9zh49qHHCjDMm6oVTJM61k1A,1958
+osism/commands/reconciler.py,sha256=ubQfX8j13s3NuMKnT0Lt6O-szf7Z1V02AfsMQFHmO74,2209
 osism/commands/server.py,sha256=avmoOv5rjOi-fN2A-27cPwOtiy2Q2j6UFtCh3QrfWAI,7512
 osism/commands/service.py,sha256=A1lgAlGeCJpbFFqF55DRWPcCirIgpU0dzjzVLZ0mz3k,2649
 osism/commands/set.py,sha256=xLBi2DzbVQo2jb3-cOIE9In5UB3vFxquQJkDN-EsfhM,1425
@@ -44,28 +44,28 @@ osism/tasks/kolla.py,sha256=wJQpWn_01iWLkr7l7T7RNrQGfRgsgmYi4WQlTmNGvew,618
 osism/tasks/kubernetes.py,sha256=VzXq_VrYU_CLm4cOruqnE3Kq2ydfO9glZ3p0bp3OYoc,625
 osism/tasks/netbox.py,sha256=g0gL5QImiRTHqixRxze7LfNqPth7cXqLzVWQDUJLDjE,5928
 osism/tasks/openstack.py,sha256=g15tCll5vP1pC6ysxRCTZxplsdGmXbxaCH3k1Qdv5Xg,6367
-osism/tasks/reconciler.py,sha256=6iC0EYxeGvitzU2NsRqQzUEDZWW6Il3jgq_IRTN0sZg,1855
+osism/tasks/reconciler.py,sha256=phbSV6urILqq9mHGMYDFwSfx8bLZmldwgEi8sMWs8RA,2040
 osism/tasks/conductor/__init__.py,sha256=eBkisjRj0YRT0AArvuvpIHGNEqEijsNvR_55BuVX62I,1600
 osism/tasks/conductor/config.py,sha256=tvfuYNgvw0F_ZbvrjqnyHfrj3vF6z0zhsRtGNu-Lgvo,3410
-osism/tasks/conductor/ironic.py,sha256=tIhKH5EWvqzjVtZr32du8_jiVDP_9mFgTkxBjmtEm6g,16487
+osism/tasks/conductor/ironic.py,sha256=VT8JyYNh4IDWJ8QTIo46IokILKpGhINfLHjQvwz4FSU,16337
 osism/tasks/conductor/netbox.py,sha256=5Nc7wrriDOtSuru1KDLt9QpA54vC7tXDPB2J0JP9GKo,11393
 osism/tasks/conductor/utils.py,sha256=-a0-pRuhV4Fjj0SgdgBqtRJtAdGdqck5pzfi6NYBApU,2338
 osism/tasks/conductor/sonic/__init__.py,sha256=oxTTl_MGK4iWK9uNDRNlULtGrDGCQHrlJZ04weh_Lh8,777
 osism/tasks/conductor/sonic/bgp.py,sha256=PC6gGI5bCj2PCXcNGyMV9-EdlJWDsYaodzxigmYSZvw,3088
 osism/tasks/conductor/sonic/cache.py,sha256=Asv2k3nLJejuq7iB0a_LyK8dEmJzypP9v3OHkNY3GwI,3438
-osism/tasks/conductor/sonic/config_generator.py,sha256=Z2i6SvKp27EI-dK9fkSDo51ghbIIqTgM7qK0-xJtVwU,35098
+osism/tasks/conductor/sonic/config_generator.py,sha256=Fww6uOC7DplhsqR_jW9PHPB0pAAY1AiTGeNAQ2BUN4k,39259
 osism/tasks/conductor/sonic/connections.py,sha256=NvRjwJv3NF3ry5Xe9qHzk7pQbfDQHYx_j3ATRMUs7gA,14244
-osism/tasks/conductor/sonic/constants.py,sha256=nfsiKV1I5iiXPAUzkZgnFPWuSB_oy8xg3gNEZjn1Hb4,2194
+osism/tasks/conductor/sonic/constants.py,sha256=HjVFwmH-AN3np1qN97ahEAcwz2-4cHa-pA9pXWqWsqs,2219
 osism/tasks/conductor/sonic/device.py,sha256=ZYJA0bQ8waKWStzWUPxbcwNWa2Z_hMB3pqs8aA_nxXA,2458
 osism/tasks/conductor/sonic/exporter.py,sha256=25L1vbi84ZQD0xNHNTWk-anTz5QRkGJskCECBkeGQw4,8882
-osism/tasks/conductor/sonic/interface.py,sha256=MM-HrYlVdh_5fYSKto_38DC4RcfzoqBGEYFxk-Tz760,32233
-osism/tasks/conductor/sonic/sync.py,sha256=Jh2xbBv_yyrEJZZZkZRIk7vH0WV-IS4CA-4qQp56I2U,7823
+osism/tasks/conductor/sonic/interface.py,sha256=318wOwXYSSMKTPP2WSZIps-JvIkCQ2gYdQs9ZYHXwwg,38957
+osism/tasks/conductor/sonic/sync.py,sha256=fpgsQVwq6Hb7eeDHhLkAqx5BkaK3Ce_m_WvmWEsJyOo,9182
 osism/utils/__init__.py,sha256=gN5VtLJfrvyn6_snuTte7YR-vDygkpbORopIV8qSEsA,6064
-osism-0.20250621.0.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
-osism-0.20250621.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-osism-0.20250621.0.dist-info/METADATA,sha256=0nTzEqeDkHWwUyPJftfn6_Az0MP26rQjhMQNPffXkdM,2903
-osism-0.20250621.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-osism-0.20250621.0.dist-info/entry_points.txt,sha256=X1KbMeQim23k_lGGDFz8ldQIrdCrq8mKnFWgYrrEZI0,3469
-osism-0.20250621.0.dist-info/pbr.json,sha256=nvF1nN4eUUNsct1PT2Fq9FvN3QNGbPvpeeWGR0BjJjU,47
-osism-0.20250621.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
-osism-0.20250621.0.dist-info/RECORD,,
+osism-0.20250627.0.dist-info/licenses/AUTHORS,sha256=oWotd63qsnNR945QLJP9mEXaXNtCMaesfo8ZNuLjwpU,39
+osism-0.20250627.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+osism-0.20250627.0.dist-info/METADATA,sha256=z9qQh_i8ZIPgWTACdHuDa5mZKbmi9vWrTPQ5xUivpUI,2904
+osism-0.20250627.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osism-0.20250627.0.dist-info/entry_points.txt,sha256=eRq0DXdl4z2DdmPta6dqpzMe1M0DaUCNw9i4Jgdfhf0,3426
+osism-0.20250627.0.dist-info/pbr.json,sha256=rZRiHfI7rgnmVfh2COv00pQVKhMCCu6cw0bifLp9cVw,47
+osism-0.20250627.0.dist-info/top_level.txt,sha256=8L8dsI9hcaGHsdnR4k_LN9EM78EhwrXRFHyAryPXZtY,6
+osism-0.20250627.0.dist-info/RECORD,,

{osism-0.20250621.0.dist-info → osism-0.20250627.0.dist-info}/entry_points.txt

@@ -42,11 +42,10 @@ manage flavors = osism.commands.manage:Flavors
 manage image clusterapi = osism.commands.manage:ImageClusterapi
 manage image octavia = osism.commands.manage:ImageOctavia
 manage images = osism.commands.manage:Images
-manage ironic = osism.commands.netbox:Ironic
 manage netbox = osism.commands.netbox:Manage
 manage server list = osism.commands.server:ServerList
 manage server migrate = osism.commands.server:ServerMigrate
-manage sonic = osism.commands.sync:Sonic
+manage sonic = osism.commands.manage:Sonic
 manage volume list = osism.commands.volume:VolumeList
 netbox = osism.commands.netbox:Console
 noset bootstrap = osism.commands.noset:NoBootstrap

osism-0.20250627.0.dist-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "e1bd41d", "is_release": false}

osism-0.20250621.0.dist-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "ed0a34c", "is_release": false}