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

osism/tasks/conductor/sonic/config_generator.py

@@ -11,6 +11,7 @@ from loguru import logger
 
 from osism import utils
 from osism.tasks.conductor.netbox import (
+    get_device_interface_ips,
     get_device_loopbacks,
     get_device_oob_ip,
     get_device_vlans,
@@ -29,6 +30,7 @@ from .interface import (
 from .connections import (
     get_connected_interfaces,
     get_connected_device_for_sonic_interface,
+    get_connected_interface_ipv4_address,
 )
 from .cache import get_cached_device_interfaces
 
@@ -73,6 +75,12 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
     # Get Loopback configuration from NetBox
     loopback_info = get_device_loopbacks(device)
 
+    # Get interface IP addresses from NetBox
+    interface_ips = get_device_interface_ips(device)
+
+    # Get IPv4 addresses from transfer role prefixes
+    transfer_ips = _get_transfer_role_ipv4_addresses(device)
+
     # Get breakout port configuration from NetBox
     breakout_info = detect_breakout_ports(device)
 
@@ -186,7 +194,14 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
     )
 
     # Add interface configurations
-    _add_interface_configurations(config, connected_interfaces, portchannel_info)
+    _add_interface_configurations(
+        config,
+        connected_interfaces,
+        portchannel_info,
+        interface_ips,
+        netbox_interfaces,
+        device,
+    )
 
     # Add BGP configurations
     _add_bgp_configurations(
@@ -196,6 +211,10 @@ def generate_sonic_config(device, hwsku, device_as_mapping=None):
         portchannel_info,
         device,
         device_as_mapping,
+        interface_ips,
+        netbox_interfaces,
+        transfer_ips,
+        utils.nb,
     )
 
     # Add NTP server configuration (device-specific)
@@ -531,7 +550,14 @@ def _add_tagged_vlans_to_ports(config, vlan_info, netbox_interfaces, device):
             config["PORT"][port_name]["tagged_vlans"] = tagged_vlans
 
 
-def _add_interface_configurations(config, connected_interfaces, portchannel_info):
+def _add_interface_configurations(
+    config,
+    connected_interfaces,
+    portchannel_info,
+    interface_ips,
+    netbox_interfaces,
+    device,
+):
     """Add INTERFACE configuration for connected interfaces."""
     for port_name in config["PORT"]:
         # Check if this port is in the connected interfaces set and not a port channel member
@@ -539,8 +565,148 @@ def _add_interface_configurations(config, connected_interfaces, portchannel_info
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            # Add interface to INTERFACE section with ipv6_use_link_local_only enabled
-            config["INTERFACE"][port_name] = {"ipv6_use_link_local_only": "enable"}
+            # Find the NetBox interface name for this SONiC port
+            netbox_interface_name = None
+            if port_name in netbox_interfaces:
+                netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+
+            # Check if this interface has an IPv4 address assigned
+            ipv4_address = None
+            if netbox_interface_name and netbox_interface_name in interface_ips:
+                ipv4_address = interface_ips[netbox_interface_name]
+                logger.info(
+                    f"Interface {port_name} ({netbox_interface_name}) has IPv4 address: {ipv4_address}"
+                )
+
+            if ipv4_address:
+                # If IPv4 address is available, configure the interface with it
+                # Add base interface entry (similar to VLAN_INTERFACE and LOOPBACK_INTERFACE patterns)
+                config["INTERFACE"][port_name] = {}
+                # Add IP address suffixed entry with scope and family parameters
+                config["INTERFACE"][f"{port_name}|{ipv4_address}"] = {
+                    "scope": "global",
+                    "family": "IPv4",
+                }
+                logger.info(
+                    f"Configured interface {port_name} with IPv4 address {ipv4_address}"
+                )
+            else:
+                # Add interface to INTERFACE section with ipv6_use_link_local_only enabled
+                config["INTERFACE"][port_name] = {"ipv6_use_link_local_only": "enable"}
+                logger.debug(
+                    f"Configured interface {port_name} with IPv6 link-local only"
+                )
+
+
+def _get_transfer_role_ipv4_addresses(device):
+    """Get IPv4 addresses from IP prefixes with 'transfer' role.
+
+    Args:
+        device: NetBox device object
+
+    Returns:
+        dict: Dictionary mapping interface names to their transfer role IPv4 addresses
+              {
+                  'interface_name': 'ip_address/prefix_length',
+                  ...
+              }
+    """
+    transfer_ips = {}
+
+    try:
+        # Get all interfaces for the device
+        interfaces = list(utils.nb.dcim.interfaces.filter(device_id=device.id))
+
+        for interface in interfaces:
+            # Skip management interfaces and virtual interfaces
+            if interface.mgmt_only or (
+                hasattr(interface, "type")
+                and interface.type
+                and interface.type.value == "virtual"
+            ):
+                continue
+
+            # Get IP addresses assigned to 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:
+                    try:
+                        ip_obj = ipaddress.ip_interface(ip_addr.address)
+                        if ip_obj.version == 4:
+                            # Check if this IP belongs to a prefix with 'transfer' role
+                            # Query for the prefix this IP belongs to
+                            prefixes = utils.nb.ipam.prefixes.filter(
+                                contains=str(ip_obj.ip)
+                            )
+
+                            for prefix in prefixes:
+                                # Check if prefix has role and it's 'transfer'
+                                if hasattr(prefix, "role") and prefix.role:
+                                    if prefix.role.slug == "transfer":
+                                        transfer_ips[interface.name] = ip_addr.address
+                                        logger.debug(
+                                            f"Found transfer role IPv4 {ip_addr.address} on interface {interface.name} of device {device.name}"
+                                        )
+                                        break
+
+                            # Break after first IPv4 found (transfer or not)
+                            if interface.name in transfer_ips:
+                                break
+                    except (ValueError, ipaddress.AddressValueError):
+                        # Skip invalid IP addresses
+                        continue
+
+    except Exception as e:
+        logger.warning(
+            f"Failed to get transfer role IPv4 addresses for device {device.name}: {e}"
+        )
+
+    return transfer_ips
+
+
+def _has_direct_ipv4_address(port_name, interface_ips, netbox_interfaces):
+    """Check if an interface has a direct IPv4 address assigned.
+
+    Args:
+        port_name: SONiC interface name (e.g., "Ethernet0")
+        interface_ips: Dict mapping NetBox interface names to IPv4 addresses
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+
+    Returns:
+        bool: True if interface has a direct IPv4 address, False otherwise
+    """
+    if not interface_ips or not netbox_interfaces:
+        return False
+
+    if port_name in netbox_interfaces:
+        netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+        return netbox_interface_name in interface_ips
+
+    return False
+
+
+def _has_transfer_role_ipv4(port_name, transfer_ips, netbox_interfaces):
+    """Check if an interface has an IPv4 from a transfer role prefix.
+
+    Args:
+        port_name: SONiC interface name (e.g., "Ethernet0")
+        transfer_ips: Dict mapping NetBox interface names to transfer role IPv4 addresses
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+
+    Returns:
+        bool: True if interface has a transfer role IPv4 address, False otherwise
+    """
+    if not transfer_ips or not netbox_interfaces:
+        return False
+
+    if port_name in netbox_interfaces:
+        netbox_interface_name = netbox_interfaces[port_name]["netbox_name"]
+        return netbox_interface_name in transfer_ips
+
+    return False
 
 
 def _add_bgp_configurations(
@@ -550,52 +716,189 @@ def _add_bgp_configurations(
     portchannel_info,
     device,
     device_as_mapping=None,
+    interface_ips=None,
+    netbox_interfaces=None,
+    transfer_ips=None,
+    netbox=None,
 ):
-    """Add BGP configurations."""
+    """Add BGP configurations.
+
+    Args:
+        config: Configuration dictionary to update
+        connected_interfaces: Set of connected interface names
+        connected_portchannels: Set of connected port channel names
+        portchannel_info: Port channel membership information
+        device: NetBox device object
+        device_as_mapping: Mapping of device names to AS numbers
+        interface_ips: Dict of direct IPv4 addresses on interfaces
+        netbox_interfaces: Dict mapping SONiC names to NetBox interface info
+        transfer_ips: Dict of IPv4 addresses from transfer role prefixes
+        netbox: NetBox API client for querying connected interface IPs
+    """
     # Add BGP_NEIGHBOR_AF configuration for connected interfaces
     for port_name in config["PORT"]:
+        has_direct_ipv4 = _has_direct_ipv4_address(
+            port_name, interface_ips, netbox_interfaces
+        )
+        has_transfer_ipv4 = _has_transfer_role_ipv4(
+            port_name, transfer_ips, netbox_interfaces
+        )
+
         if (
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            ipv4_key = f"default|{port_name}|ipv4_unicast"
-            ipv6_key = f"default|{port_name}|ipv6_unicast"
-            config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
-            config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
+            # Include interfaces with transfer role IPv4 or no direct IPv4
+            if has_transfer_ipv4 or not has_direct_ipv4:
+                # Try to get the IPv4 address of the connected endpoint interface
+                connected_ipv4 = None
+                if netbox:
+                    connected_ipv4 = get_connected_interface_ipv4_address(
+                        device, port_name, netbox
+                    )
+
+                # For BGP_NEIGHBOR_AF, always use interface name like IPv6 does
+                neighbor_id = port_name
+
+                ipv4_key = f"default|{neighbor_id}|ipv4_unicast"
+                config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
+
+                # Only add ipv6_unicast if v6only would be true (no transfer role IPv4)
+                if not has_transfer_ipv4:
+                    ipv6_key = f"default|{neighbor_id}|ipv6_unicast"
+                    config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR_AF with ipv4_unicast and ipv6_unicast for interface {port_name} (no direct IPv4)"
+                    )
+                else:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR_AF with ipv4_unicast only for interface {port_name} (transfer role IPv4, v6only=false)"
+                    )
+            elif has_direct_ipv4 and not has_transfer_ipv4:
+                logger.info(
+                    f"Excluding interface {port_name} from BGP detection (has direct IPv4 address, not transfer role)"
+                )
 
     # Add BGP_NEIGHBOR_AF configuration for connected port channels
     for pc_name in connected_portchannels:
-        ipv4_key = f"default|{pc_name}|ipv4_unicast"
-        ipv6_key = f"default|{pc_name}|ipv6_unicast"
+        # Try to get the IPv4 address of the connected endpoint interface for port channel
+        connected_ipv4 = None
+        if netbox:
+            connected_ipv4 = get_connected_interface_ipv4_address(
+                device, pc_name, netbox
+            )
+
+        # For BGP_NEIGHBOR_AF, always use port channel name like interfaces
+        neighbor_id = pc_name
+
+        ipv4_key = f"default|{neighbor_id}|ipv4_unicast"
+        ipv6_key = f"default|{neighbor_id}|ipv6_unicast"
         config["BGP_NEIGHBOR_AF"][ipv4_key] = {"admin_status": "true"}
         config["BGP_NEIGHBOR_AF"][ipv6_key] = {"admin_status": "true"}
 
     # Add BGP_NEIGHBOR configuration for connected interfaces
     for port_name in config["PORT"]:
+        has_direct_ipv4 = _has_direct_ipv4_address(
+            port_name, interface_ips, netbox_interfaces
+        )
+        has_transfer_ipv4 = _has_transfer_role_ipv4(
+            port_name, transfer_ips, netbox_interfaces
+        )
+
         if (
             port_name in connected_interfaces
             and port_name not in portchannel_info["member_mapping"]
         ):
-            neighbor_key = f"default|{port_name}"
+            # Include interfaces with transfer role IPv4 or no direct IPv4
+            if has_transfer_ipv4 or not has_direct_ipv4:
+                # Try to get the IPv4 address of the connected endpoint interface
+                connected_ipv4 = None
+                if netbox:
+                    connected_ipv4 = get_connected_interface_ipv4_address(
+                        device, port_name, netbox
+                    )
 
-            # Determine peer_type based on connected device AS
-            peer_type = "external"  # Default
-            connected_device = get_connected_device_for_sonic_interface(
-                device, port_name
-            )
-            if connected_device:
-                peer_type = _determine_peer_type(
-                    device, connected_device, device_as_mapping
+                # Use the connected interface's IPv4 address if available, otherwise use interface name
+                if connected_ipv4:
+                    neighbor_key = f"default|{connected_ipv4}"
+                    logger.debug(
+                        f"Using connected interface IPv4 address {connected_ipv4} for BGP neighbor on {port_name}"
+                    )
+                else:
+                    neighbor_key = f"default|{port_name}"
+                    logger.debug(
+                        f"No connected interface IPv4 found, using interface name {port_name} for BGP neighbor"
+                    )
+
+                # Determine peer_type based on connected device AS
+                peer_type = "external"  # Default
+                connected_device = get_connected_device_for_sonic_interface(
+                    device, port_name
                 )
+                if connected_device:
+                    peer_type = _determine_peer_type(
+                        device, connected_device, device_as_mapping
+                    )
 
-            config["BGP_NEIGHBOR"][neighbor_key] = {
-                "peer_type": peer_type,
-                "v6only": "true",
-            }
+                # Set v6only based on whether interface has transfer role IPv4
+                # - Transfer role IPv4: v6only=false (dual-stack BGP)
+                # - No direct IPv4: v6only=true (IPv6-only BGP)
+                bgp_neighbor_config = {
+                    "peer_type": peer_type,
+                    "v6only": "false" if has_transfer_ipv4 else "true",
+                }
+
+                # If using IP address as key, also store the local address
+                if connected_ipv4:
+                    # Get the local interface IPv4 address
+                    local_ipv4 = None
+                    if port_name in netbox_interfaces:
+                        netbox_interface_name = netbox_interfaces[port_name][
+                            "netbox_name"
+                        ]
+                        if netbox_interface_name in interface_ips:
+                            local_ipv4 = interface_ips[netbox_interface_name].split(
+                                "/"
+                            )[0]
+                        elif netbox_interface_name in transfer_ips:
+                            local_ipv4 = transfer_ips[netbox_interface_name].split("/")[
+                                0
+                            ]
+
+                    if local_ipv4:
+                        bgp_neighbor_config["local_addr"] = local_ipv4
+
+                config["BGP_NEIGHBOR"][neighbor_key] = bgp_neighbor_config
+
+                if has_transfer_ipv4:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR for interface {port_name} (transfer role IPv4, v6only=false)"
+                    )
+                else:
+                    logger.debug(
+                        f"Added BGP_NEIGHBOR for interface {port_name} (no direct IPv4, v6only=true)"
+                    )
 
     # Add BGP_NEIGHBOR configuration for connected port channels
     for pc_name in connected_portchannels:
-        neighbor_key = f"default|{pc_name}"
+        # Try to get the IPv4 address of the connected endpoint interface for port channel
+        connected_ipv4 = None
+        if netbox:
+            connected_ipv4 = get_connected_interface_ipv4_address(
+                device, pc_name, netbox
+            )
+
+        # Use the connected interface's IPv4 address if available, otherwise use port channel name
+        if connected_ipv4:
+            neighbor_key = f"default|{connected_ipv4}"
+            logger.debug(
+                f"Using connected interface IPv4 address {connected_ipv4} for BGP neighbor on {pc_name}"
+            )
+        else:
+            neighbor_key = f"default|{pc_name}"
+            logger.debug(
+                f"No connected interface IPv4 found, using port channel name {pc_name} for BGP neighbor"
+            )
 
         # Determine peer_type based on connected device AS
         peer_type = "external"  # Default
@@ -605,11 +908,23 @@ def _add_bgp_configurations(
                 device, connected_device, device_as_mapping
             )
 
-        config["BGP_NEIGHBOR"][neighbor_key] = {
+        bgp_neighbor_config = {
             "peer_type": peer_type,
             "v6only": "true",
         }
 
+        # If using IP address as key, also store the local address
+        if connected_ipv4:
+            # For port channels, get the local IPv4 address from interface IPs
+            # Note: Port channels don't have direct IP assignments in NetBox,
+            # so we use the connected interface IP logic
+            local_ipv4 = None
+            # Port channels don't have NetBox interface entries,
+            # so we skip local_addr for port channels for now
+            # TODO: Implement port channel local address lookup if needed
+
+        config["BGP_NEIGHBOR"][neighbor_key] = bgp_neighbor_config
+
 
 def _get_connected_device_for_interface(device, interface_name):
     """Get the connected device for a given interface name.

osism/tasks/conductor/sonic/connections.py

@@ -387,3 +387,126 @@ def get_device_bgp_neighbors_via_loopback(
         logger.warning(f"Could not process BGP neighbors for device {device.name}: {e}")
 
     return bgp_neighbors
+
+
+def get_connected_interface_ipv4_address(device, sonic_port_name, netbox):
+    """
+    Get the IPv4 address(es) of the connected endpoint interface for a given SONiC port.
+    Checks for direct IP addresses first, then for FHRP VIP addresses.
+
+    Args:
+        device: The SONiC device
+        sonic_port_name: The SONiC port name
+        netbox: The NetBox API client
+
+    Returns:
+        - For direct IP: The IPv4 address string of the connected interface
+        - For FHRP VIP: The first VIP address found (if multiple VIPs exist, logs all but returns first)
+        - None if no addresses found
+    """
+    try:
+        interface = netbox.dcim.interfaces.get(
+            device_id=device.id, name=sonic_port_name
+        )
+        if not interface:
+            return None
+
+        # Check if interface has connected_endpoints using the modern API
+        if not (
+            hasattr(interface, "connected_endpoints") and interface.connected_endpoints
+        ):
+            return None
+
+        # Ensure connected_endpoints_reachable is True
+        if not getattr(interface, "connected_endpoints_reachable", False):
+            return None
+
+        # Process each connected endpoint to find the first valid interface
+        connected_interface = None
+        for endpoint in interface.connected_endpoints:
+            if hasattr(endpoint, "id"):
+                connected_interface = endpoint
+                break
+
+        if not connected_interface:
+            return None
+
+        # First, try to get direct IPv4 addresses assigned to the connected interface
+        ip_addresses = netbox.ipam.ip_addresses.filter(
+            assigned_object_id=connected_interface.id,
+        )
+
+        for ip_address in ip_addresses:
+            # Check if it's an IPv4 address
+            if "/" in str(ip_address.address):
+                address = str(ip_address.address).split("/")[0]
+                if "." in address:  # IPv4 address
+                    logger.debug(
+                        f"Found direct IPv4 address {address} on connected interface "
+                        f"{connected_interface.name} for port {sonic_port_name}"
+                    )
+                    return address
+
+        # If no direct IP found, check for FHRP group membership and VIP addresses
+        logger.debug(
+            f"No direct IPv4 found on {connected_interface.name}, checking for FHRP VIP addresses"
+        )
+
+        # Get FHRP group assignments for the connected interface
+        fhrp_assignments = netbox.ipam.fhrp_group_assignments.filter(
+            interface_type="dcim.interface", interface_id=connected_interface.id
+        )
+
+        # Get all VIP addresses once to avoid repeated API calls
+        try:
+            all_vip_addresses = netbox.ipam.ip_addresses.filter(role="vip")
+        except Exception as vip_e:
+            logger.debug(f"Could not query VIP addresses: {vip_e}")
+            all_vip_addresses = []
+
+        # Collect all VIP IPv4 addresses from all FHRP groups this interface belongs to
+        vip_addresses_found = []
+
+        for assignment in fhrp_assignments:
+            if not assignment.group:
+                continue
+
+            # Find VIP addresses assigned to this specific FHRP group
+            for vip in all_vip_addresses:
+                # Check if this VIP is assigned to the current FHRP group
+                if (
+                    hasattr(vip, "assigned_object_type")
+                    and vip.assigned_object_type == "ipam.fhrpgroup"
+                    and hasattr(vip, "assigned_object_id")
+                    and vip.assigned_object_id == assignment.group.id
+                ):
+                    # Check if it's an IPv4 address
+                    if "/" in str(vip.address):
+                        address = str(vip.address).split("/")[0]
+                        if "." in address:  # IPv4 address
+                            vip_addresses_found.append(address)
+                            logger.debug(
+                                f"Found FHRP VIP address {address} for connected interface "
+                                f"{connected_interface.name} (FHRP group: {assignment.group.name or assignment.group.id}) "
+                                f"for port {sonic_port_name}"
+                            )
+
+        # Return the first VIP address found (for BGP neighbor compatibility)
+        if vip_addresses_found:
+            logger.debug(
+                f"Found {len(vip_addresses_found)} VIP addresses for port {sonic_port_name}: {vip_addresses_found}"
+            )
+            logger.debug(f"Returning first VIP address: {vip_addresses_found[0]}")
+            return vip_addresses_found[0]
+
+        logger.debug(
+            f"No IPv4 address (direct or FHRP VIP) found on connected interface "
+            f"{connected_interface.name} for port {sonic_port_name}"
+        )
+        return None
+
+    except Exception as e:
+        logger.warning(
+            f"Could not get connected interface IPv4 for port {sonic_port_name}: {e}"
+        )
+        return None

osism/tasks/conductor/sonic/interface.py

@@ -697,7 +697,9 @@ def detect_breakout_ports(device):
                                     )
 
                                 # Calculate breakout mode
-                                if interface_speed == 25000 and num_subports == 4:
+                                if interface_speed == 10000 and num_subports == 4:
+                                    brkout_mode = "4x10G"
+                                elif interface_speed == 25000 and num_subports == 4:
                                     brkout_mode = "4x25G"
                                 elif interface_speed == 50000 and num_subports == 4:
                                     brkout_mode = "4x50G"

osism/tasks/openstack.py

@@ -65,23 +65,43 @@ def baremetal_node_show(self, node_id_or_name, ignore_missing=False):
 @app.task(bind=True, name="osism.tasks.openstack.baremetal_node_list")
 def baremetal_node_list(self):
     conn = utils.get_openstack_connection()
-    nodes = conn.baremetal.nodes()
-    result = []
+    result = conn.baremetal.nodes()
+    return list(result)
 
-    # Simulate the output of the OpenStack CLI with -f json and without --long
-    for node in nodes:
-        result.append(
-            {
-                "UUID": node.id,
-                "Name": node.name,
-                "Instance UUID": node.instance_id,
-                "Power State": node.power_state,
-                "Provisioning State": node.provision_state,
-                "Maintenance": node.is_maintenance,
-            }
-        )
 
-    return result
+def get_baremetal_nodes():
+    """Get all baremetal nodes with their details.
+
+    This is a generalized function that can be used by both
+    CLI commands and API endpoints to retrieve baremetal node information.
+
+    Returns:
+        list: List of dictionaries containing node information
+    """
+    conn = utils.get_openstack_connection()
+    nodes = conn.baremetal.nodes(details=True)
+
+    # Convert generator to list and extract relevant fields
+    node_list = []
+    for node in nodes:
+        node_info = {
+            "uuid": node.get("uuid"),
+            "name": node.get("name"),
+            "power_state": node.get("power_state"),
+            "provision_state": node.get("provision_state"),
+            "maintenance": node.get("maintenance"),
+            "instance_uuid": node.get("instance_uuid"),
+            "driver": node.get("driver"),
+            "resource_class": node.get("resource_class"),
+            "properties": node.get("properties", {}),
+            "extra": node.get("extra", {}),
+            "last_error": node.get("last_error"),
+            "created_at": node.get("created_at"),
+            "updated_at": node.get("updated_at"),
+        }
+        node_list.append(node_info)
+
+    return node_list
 
 
 @app.task(bind=True, name="osism.tasks.openstack.baremetal_node_validate")

osism/utils/__init__.py

@@ -73,7 +73,7 @@ try:
             )
         if (
             "NETBOX_TOKEN" not in secondary_nb_settings
-            or not secondary_nb_settings["NETBOX_TOKEN"]
+            or not str(secondary_nb_settings["NETBOX_TOKEN"]).strip()
         ):
             raise ValueError(
                 "All NETBOX_TOKEN values in the elements of setting NETBOX_SECONDARIES need to be valid NetBox tokens"
@@ -82,7 +82,7 @@ try:
         secondary_nb_list.append(
             get_netbox_connection(
                 secondary_nb_settings["NETBOX_URL"],
-                secondary_nb_settings["NETBOX_TOKEN"],
+                str(secondary_nb_settings["NETBOX_TOKEN"]),
                 secondary_nb_settings.get("IGNORE_SSL_ERRORS", True),
             )
         )