nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/dcim/forms.py

@@ -2112,9 +2112,9 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
         queryset=ClusterGroup.objects.all(),
         required=False,
         null_option="None",
-        initial_params={"clusters": "$cluster"},
+        initial_params={"clusters__in": "$clusters"},
     )
-    cluster = DynamicModelChoiceField(
+    clusters = DynamicModelMultipleChoiceField(
         queryset=Cluster.objects.all(),
         required=False,
         query_params={"cluster_group": "$cluster_group"},
@@ -2160,7 +2160,7 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
             "primary_ip6",
             "secrets_group",
             "cluster_group",
-            "cluster",
+            "clusters",
             "tenant_group",
             "tenant",
             "vrfs",
@@ -2238,6 +2238,7 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
                 self.initial["location"] = self.instance.parent_bay.device.location_id
                 self.initial["rack"] = self.instance.parent_bay.device.rack_id
 
+            self.initial["clusters"] = self.instance.clusters.values_list("id", flat=True)
             self.initial["vrfs"] = self.instance.vrfs.values_list("id", flat=True)
 
         else:
@@ -2274,6 +2275,7 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
     def save(self, *args, **kwargs):
         instance = super().save(*args, **kwargs)
         instance.vrfs.set(self.cleaned_data["vrfs"])
+        instance.clusters.set(self.cleaned_data["clusters"])
         return instance
 
 
@@ -2306,7 +2308,12 @@ class DeviceBulkEditForm(
     rack_group = DynamicModelChoiceField(
         queryset=RackGroup.objects.all(), required=False, query_params={"location": "$location"}
     )
-    cluster = DynamicModelChoiceField(queryset=Cluster.objects.all(), required=False)
+    add_clusters = DynamicModelMultipleChoiceField(
+        queryset=Cluster.objects.all(), required=False, label="Add to clusters"
+    )
+    remove_clusters = DynamicModelMultipleChoiceField(
+        queryset=Cluster.objects.all(), required=False, label="Remove from clusters"
+    )
     comments = CommentField(widget=SmallTextarea, label="Comments")
     tenant = DynamicModelChoiceField(queryset=Tenant.objects.all(), required=False)
     platform = DynamicModelChoiceField(queryset=Platform.objects.all(), required=False)
@@ -2329,7 +2336,6 @@ class DeviceBulkEditForm(
             "rack",
             "position",
             "face",
-            "cluster",
             "comments",
             "secrets_group",
             "device_redundancy_group",
@@ -4571,7 +4577,7 @@ class BaseVCMemberFormSet(forms.BaseModelFormSet):
                 vc_position_list.append(vc_position)
 
 
-class DeviceVCMembershipForm(forms.ModelForm):
+class DeviceVCMembershipForm(BootstrapMixin, forms.ModelForm):
     class Meta:
         model = Device
         fields = [

nautobot/dcim/graphql/types.py

@@ -68,6 +68,7 @@ class DeviceType(OptimizedNautobotObjectType):
     all_power_ports = graphene.List("nautobot.dcim.graphql.types.PowerPortType")
     all_power_outlets = graphene.List("nautobot.dcim.graphql.types.PowerOutletType")
     all_rear_ports = graphene.List("nautobot.dcim.graphql.types.RearPortType")
+    cluster = graphene.Field("nautobot.virtualization.graphql.types.ClusterType")
     common_vc_interfaces = graphene.List("nautobot.dcim.graphql.types.InterfaceType")
     dynamic_groups = graphene.List("nautobot.extras.graphql.types.DynamicGroupType")
     primary_ip = graphene.Field("nautobot.ipam.graphql.types.IPAddressType")

nautobot/dcim/migrations/0075_add_deviceclusterassignment.py

@@ -0,0 +1,52 @@
+import uuid
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0074_alter_rack_u_height"),
+        ("virtualization", "0030_alter_virtualmachine_local_config_context_data_owner_content_type_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="DeviceClusterAssignment",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True
+                    ),
+                ),
+                (
+                    "cluster",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="device_assignments",
+                        to="virtualization.cluster",
+                    ),
+                ),
+                (
+                    "device",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="cluster_assignments",
+                        to="dcim.device",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["device", "cluster"],
+                "unique_together": {("device", "cluster")},
+            },
+        ),
+        migrations.AddField(
+            model_name="device",
+            name="clusters",
+            field=models.ManyToManyField(
+                blank=True, related_name="devices", through="dcim.DeviceClusterAssignment", to="virtualization.cluster"
+            ),
+        ),
+    ]

nautobot/dcim/migrations/0076_device_cluster_to_clusters_data_migration.py

@@ -0,0 +1,40 @@
+from django.db import migrations
+
+
+def migrate_device_cluster_assignments(apps, schema_editor):
+    """
+    Migrate existing device cluster assignments from the old ForeignKey field
+    to the new many-to-many relationship through DeviceClusterAssignment.
+    """
+    Device = apps.get_model("dcim", "Device")
+    DeviceClusterAssignment = apps.get_model("dcim", "DeviceClusterAssignment")
+    devices_with_clusters = Device.objects.filter(cluster__isnull=False).select_related("cluster")
+    assignments_to_create = []
+    for device in devices_with_clusters:
+        assignments_to_create.append(DeviceClusterAssignment(device=device, cluster=device.cluster))
+    if assignments_to_create:
+        DeviceClusterAssignment.objects.bulk_create(assignments_to_create, batch_size=1000)
+
+
+def reverse_migrate_device_cluster_assignments(apps, schema_editor):
+    """
+    Reverse migration - restore the cluster field from DeviceClusterAssignment records.
+    Note: This can only restore one cluster per device if multiple exist.
+    """
+    DeviceClusterAssignment = apps.get_model("dcim", "DeviceClusterAssignment")
+
+    # For each device, get the first cluster assignment and set it as the device's cluster
+    for assignment in DeviceClusterAssignment.objects.select_related("device", "cluster"):
+        if not assignment.device.cluster:
+            assignment.device.cluster = assignment.cluster
+            assignment.device.save(update_fields=["cluster"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0075_add_deviceclusterassignment"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_device_cluster_assignments, reverse_migrate_device_cluster_assignments),
+    ]

nautobot/dcim/migrations/0077_remove_device_cluster.py

@@ -0,0 +1,14 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0076_device_cluster_to_clusters_data_migration"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="device",
+            name="cluster",
+        ),
+    ]

nautobot/dcim/migrations/0078_remove_device_location_tenant_name_uniqueness.py

@@ -0,0 +1,16 @@
+# Generated by Django 4.2.24 on 2025-10-07 07:18
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0077_remove_device_cluster"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="device",
+            unique_together={("rack", "position", "face"), ("virtual_chassis", "vc_position")},
+        ),
+    ]

nautobot/dcim/migrations/0079_device_name_data_migration.py

@@ -0,0 +1,59 @@
+# Generated by Django 4.2.24 on 2025-10-07 07:18
+
+from constance.models import Constance
+from django.db import migrations
+
+from nautobot.core.utils.config import get_settings_or_config
+from nautobot.dcim.choices import DeviceUniquenessChoices
+
+
+def migrate_device_uniqueness_setting(apps, schema_editor):
+    """
+    Migrate deprecated DEVICE_NAME_AS_NATURAL_KEY setting to DEVICE_UNIQUENESS and DEVICE_NAME_REQUIRED.
+    """
+    try:
+        old_value = get_settings_or_config("DEVICE_NAME_AS_NATURAL_KEY")
+    except AttributeError:
+        old_value = False
+    new_value = DeviceUniquenessChoices.NAME if old_value else DeviceUniquenessChoices.LOCATION_TENANT_NAME
+
+    # Update or create DEVICE_UNIQUENESS in Constance
+    Constance.objects.update_or_create(
+        key="DEVICE_UNIQUENESS",
+        defaults={"value": new_value},
+    )
+
+    # cleanup: remove deprecated setting entry if it exists
+    Constance.objects.filter(key="DEVICE_NAME_AS_NATURAL_KEY").delete()
+
+
+def reverse_migrate_device_uniqueness_setting(apps, schema_editor):
+    """
+    Reverse migration set DEVICE_NAME_AS_NATURAL_KEY based on DEVICE_UNIQUENESS.
+    """
+    try:
+        device_uniqueness = Constance.objects.get(key="DEVICE_UNIQUENESS").value
+    except Constance.DoesNotExist:
+        return
+
+    if device_uniqueness == DeviceUniquenessChoices.NAME:
+        Constance.objects.update_or_create(key="DEVICE_NAME_AS_NATURAL_KEY", defaults={"value": True})
+    else:
+        Constance.objects.update_or_create(key="DEVICE_NAME_AS_NATURAL_KEY", defaults={"value": False})
+
+    # cleanup: remove DEVICE_UNIQUENESS setting entry if it exists
+    Constance.objects.filter(key="DEVICE_UNIQUENESS").delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("dcim", "0078_remove_device_location_tenant_name_uniqueness"),
+        ("constance", "0003_drop_pickle"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            migrate_device_uniqueness_setting,
+            reverse_migrate_device_uniqueness_setting,
+        ),
+    ]

nautobot/dcim/models/__init__.py

@@ -31,6 +31,7 @@ from .devices import (
     Controller,
     ControllerManagedDeviceGroup,
     Device,
+    DeviceClusterAssignment,
     DeviceFamily,
     DeviceRedundancyGroup,
     DeviceType,
@@ -64,6 +65,7 @@ __all__ = (
     "Device",
     "DeviceBay",
     "DeviceBayTemplate",
+    "DeviceClusterAssignment",
     "DeviceFamily",
     "DeviceRedundancyGroup",
     "DeviceType",

nautobot/dcim/models/device_components.py

@@ -16,6 +16,7 @@ from nautobot.core.models.generics import BaseModel, PrimaryModel
 from nautobot.core.models.ordering import naturalize_interface
 from nautobot.core.models.query_functions import CollateAsChar
 from nautobot.core.models.tree_queries import TreeModel
+from nautobot.core.utils.cache import construct_cache_key
 from nautobot.core.utils.data import UtilizationData
 from nautobot.dcim.choices import (
     ConsolePortTypeChoices,
@@ -1349,4 +1350,5 @@ class ModuleBay(PrimaryModel):
 
         if self.parent_device is not None:
             # Set the has_module_bays cache key on the parent device - see Device.has_module_bays()
-            cache.set(f"nautobot.dcim.device.{self.parent_device.pk}.has_module_bays", True, timeout=5)
+            cache_key = construct_cache_key(self.parent_device, method_name="has_module_bays", branch_aware=True)
+            cache.set(cache_key, True, timeout=5)

nautobot/dcim/models/devices.py

@@ -18,18 +18,21 @@ from nautobot.core.models import BaseManager, RestrictedQuerySet
 from nautobot.core.models.fields import JSONArrayField, LaxURLField, NaturalOrderingField
 from nautobot.core.models.generics import BaseModel, OrganizationalModel, PrimaryModel
 from nautobot.core.models.tree_queries import TreeModel
+from nautobot.core.templatetags.helpers import HTML_NONE
+from nautobot.core.utils.cache import construct_cache_key
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.dcim.choices import (
     ControllerCapabilitiesChoices,
     DeviceFaceChoices,
     DeviceRedundancyGroupFailoverStrategyChoices,
+    DeviceUniquenessChoices,
     SoftwareImageFileHashingAlgorithmChoices,
     SubdeviceRoleChoices,
 )
 from nautobot.dcim.constants import MODULE_RECURSION_DEPTH_LIMIT
+from nautobot.dcim.querysets import DeviceQuerySet
 from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_driver_mapping_tool_names
 from nautobot.extras.models import ChangeLoggedModel, ConfigContextModel, RoleField, StatusField
-from nautobot.extras.querysets import ConfigContextModelQuerySet
 from nautobot.extras.utils import extras_features
 from nautobot.wireless.models import (
     ControllerManagedDeviceGroupRadioProfileAssignment,
@@ -565,13 +568,44 @@ class Device(PrimaryModel, ConfigContextModel):
         null=True,
         verbose_name="Primary IPv6",
     )
-    cluster = models.ForeignKey(
+    clusters = models.ManyToManyField(
         to="virtualization.Cluster",
-        on_delete=models.SET_NULL,
         related_name="devices",
+        through="dcim.DeviceClusterAssignment",
         blank=True,
-        null=True,
     )
+
+    @property
+    def cluster(self):
+        """
+        Returns the only cluster assigned to this device.
+
+        Deprecated. Use `clusters` instead.
+
+        TODO: Remove this property in v4.0.0
+        """
+        if self.clusters.count() > 1:
+            raise self.clusters.model.MultipleObjectsReturned(
+                "Multiple Cluster objects returned. Please refer to clusters."
+            )
+        return self.clusters.first()
+
+    @cluster.setter
+    def cluster(self, value):
+        """
+        Sets the clusters field to a single value.
+
+        Deprecated. Use `clusters` instead.
+
+        TODO: Remove this property in v4.0.0
+        """
+        # If the device hasn't been saved yet, defer the cluster assignment
+        if not self.present_in_database:
+            self._deferred_cluster = value
+            return
+
+        self.assign_cluster(value)
+
     virtual_chassis = models.ForeignKey(
         to="VirtualChassis",
         on_delete=models.SET_NULL,
@@ -632,7 +666,7 @@ class Device(PrimaryModel, ConfigContextModel):
         null=True,
     )
 
-    objects = BaseManager.from_queryset(ConfigContextModelQuerySet)()
+    objects = BaseManager.from_queryset(DeviceQuerySet)()
 
     clone_fields = [
         "device_type",
@@ -642,26 +676,27 @@ class Device(PrimaryModel, ConfigContextModel):
         "location",
         "rack",
         "status",
-        "cluster",
+        "clusters",
         "secrets_group",
     ]
 
     @classproperty  # https://github.com/PyCQA/pylint-django/issues/240
     def natural_key_field_names(cls):  # pylint: disable=no-self-argument
         """
-        When DEVICE_NAME_AS_NATURAL_KEY is set in settings or Constance, we use just the `name` for simplicity.
+        Check DEVICE_UNIQUENESS from settings or Constance and return proper field.
         """
-        if get_settings_or_config("DEVICE_NAME_AS_NATURAL_KEY"):
-            # opt-in simplified "pseudo-natural-key"
+        if get_settings_or_config("DEVICE_UNIQUENESS") == DeviceUniquenessChoices.NAME:
+            # Simplified pseudo-natural key (opt-in for name-only uniqueness)
             return ["name"]
+        elif get_settings_or_config("DEVICE_UNIQUENESS") == DeviceUniquenessChoices.LOCATION_TENANT_NAME:
+            # Full natural key based on tenant, location, and name
+            return ["name", "tenant", "location"]
         else:
-            # true natural-key given current uniqueness constraints
-            return ["name", "tenant", "location"]  # location should be last since it's potentially variadic
+            return ["pk"]
 
     class Meta:
         ordering = ("_name",)  # Name may be null
         unique_together = (
-            ("location", "tenant", "name"),  # See validate_unique below
             ("rack", "position", "face"),
             ("virtual_chassis", "vc_position"),
         )
@@ -669,15 +704,19 @@ class Device(PrimaryModel, ConfigContextModel):
     def __str__(self):
         return self.display or super().__str__()
 
-    def validate_unique(self, exclude=None):
-        # Check for a duplicate name on a device assigned to the same Location and no Tenant. This is necessary
-        # because Django does not consider two NULL fields to be equal, and thus will not trigger a violation
-        # of the uniqueness constraint without manual intervention.
-        if self.name and hasattr(self, "location") and self.tenant is None:
-            if Device.objects.exclude(pk=self.pk).filter(name=self.name, location=self.location, tenant__isnull=True):
-                raise ValidationError({"name": "A device with this name already exists."})
+    def assign_cluster(self, cluster):
+        """
+        Assign a single cluster to the device.
+        """
+        if self.clusters.count() > 1:
+            raise self.clusters.model.MultipleObjectsReturned(
+                "Multiple Cluster objects returned. Please refer to clusters."
+            )
 
-        super().validate_unique(exclude)
+        if cluster is None:
+            self.clusters.clear()
+        else:
+            self.clusters.set([cluster])
 
     def clean(self):
         from nautobot.ipam import models as ipam_models  # circular import workaround
@@ -810,15 +849,16 @@ class Device(PrimaryModel, ConfigContextModel):
                 )
 
         # A Device can only be assigned to a Cluster in the same location or parent location, if any
-        if (
-            self.cluster is not None
-            and self.location is not None
-            and self.cluster.location is not None
-            and self.cluster.location not in self.location.ancestors(include_self=True)
-        ):
-            raise ValidationError(
-                {"cluster": f"The assigned cluster belongs to a location that does not include {self.location}."}
-            )
+        # Validate any pending cluster assignment that was deferred during creation
+        # Don't validate `self.clusters` here as that's a M2M and is updated out-of-step with `self.save()`
+        if self.location is not None and hasattr(self, "_deferred_cluster"):
+            cluster = self._deferred_cluster
+            if cluster.location is not None and cluster.location not in self.location.ancestors(include_self=True):
+                raise ValidationError(
+                    {
+                        "clusters": f"Cluster {cluster} belongs to a location, {cluster.location}, that does not include {self.location}."
+                    }
+                )
 
         # Validate virtual chassis assignment
         if self.virtual_chassis and self.vc_position is None:
@@ -861,8 +901,19 @@ class Device(PrimaryModel, ConfigContextModel):
     def save(self, *args, **kwargs):
         is_new = not self.present_in_database
 
+        # to avoid circular import
+        from nautobot.dcim.custom_validators import DeviceUniquenessValidator
+
+        DeviceUniquenessValidator(self).clean()
+
         super().save(*args, **kwargs)
 
+        # Apply any pending cluster assignment that was deferred during creation
+        if hasattr(self, "_deferred_cluster"):
+            cluster = self._deferred_cluster
+            delattr(self, "_deferred_cluster")
+            self.assign_cluster(cluster)
+
         # If this is a new Device, instantiate all related components per the DeviceType definition
         if is_new:
             self.create_components()
@@ -900,7 +951,7 @@ class Device(PrimaryModel, ConfigContextModel):
         instantiated_components = []
         for model, templates in component_models:
             model.objects.bulk_create([x.instantiate(device=self) for x in templates])
-        cache_key = f"nautobot.dcim.device.{self.pk}.has_module_bays"
+        cache_key = construct_cache_key(self, method_name="has_module_bays", branch_aware=True)
         cache.delete(cache_key)
         return instantiated_components
 
@@ -1003,7 +1054,7 @@ class Device(PrimaryModel, ConfigContextModel):
         """
         Cacheable property for determining whether this Device has any ModuleBays, and therefore may contain Modules.
         """
-        cache_key = f"nautobot.dcim.device.{self.pk}.has_module_bays"
+        cache_key = construct_cache_key(self, method_name="has_module_bays", branch_aware=True)
         module_bays_exists = cache.get(cache_key)
         if module_bays_exists is None:
             module_bays_exists = self.module_bays.exists()
@@ -1109,6 +1160,35 @@ class Device(PrimaryModel, ConfigContextModel):
         )
 
 
+@extras_features("graphql")
+class DeviceClusterAssignment(BaseModel):
+    device = models.ForeignKey("dcim.Device", on_delete=models.CASCADE, related_name="cluster_assignments")
+    cluster = models.ForeignKey("virtualization.Cluster", on_delete=models.CASCADE, related_name="device_assignments")
+    is_metadata_associable_model = False
+    documentation_static_path = "docs/user-guide/core-data-model/dcim/device.html"
+
+    class Meta:
+        unique_together = ["device", "cluster"]
+        ordering = ["device", "cluster"]
+
+    def __str__(self):
+        return f"{self.device}: {self.cluster}"
+
+    def clean(self):
+        super().clean()
+        if self.device.location is not None and self.cluster.location is not None:
+            if self.cluster.location not in self.device.location.ancestors(include_self=True):
+                raise ValidationError(
+                    {
+                        "__all__": f"Cluster {self.cluster} belongs to a location, {self.cluster.location}, that does not include the location of device {self.device}, {self.device.location}"
+                    }
+                )
+
+    def save(self, *args, **kwargs):
+        self.clean()
+        super().save(*args, **kwargs)
+
+
 #
 # Virtual chassis
 #
@@ -1501,8 +1581,8 @@ class Controller(PrimaryModel):
 
     def get_capabilities_display(self):
         if not self.capabilities:
-            return format_html('<span class="text-muted">&mdash;</span>')
-        return format_html_join(" ", '<span class="label label-default">{}</span>', ((v,) for v in self.capabilities))
+            return HTML_NONE
+        return format_html_join(" ", '<span class="badge bg-secondary">{}</span>', ((v,) for v in self.capabilities))
 
     @property
     def wireless_network_assignments(self):
@@ -1598,8 +1678,8 @@ class ControllerManagedDeviceGroup(TreeModel, PrimaryModel):
 
     def get_capabilities_display(self):
         if not self.capabilities:
-            return format_html('<span class="text-muted">&mdash;</span>')
-        return format_html_join(" ", '<span class="label label-default">{}</span>', ((v,) for v in self.capabilities))
+            return HTML_NONE
+        return format_html_join(" ", '<span class="badge bg-secondary">{}</span>', ((v,) for v in self.capabilities))
 
 
 #
@@ -2117,22 +2197,6 @@ class VirtualDeviceContext(PrimaryModel):
                     raise ValidationError(
                         {f"{field}": f"{ip} is not part of an interface that belongs to this VDC's device."}
                     )
-                # Note: The validation for primary IPs `validate_primary_ips` is commented out due to the order in which Django processes form validation with
-                # Many-to-Many (M2M) fields. During form saving, Django creates the instance first before assigning the M2M fields (in this case, interfaces).
-                # As a result, the primary_ips fields could fail validation at this point because the interfaces are not yet linked to the instance,
-                # leading to validation errors.
-                # interfaces = self.interfaces.all()
-                # if IPAddressToInterface.objects.filter(ip_address=ip, interface__in=interfaces).exists():
-                #     pass
-                # elif (
-                #     ip.nat_inside is None
-                #     or not IPAddressToInterface.objects.filter(
-                #         ip_address=ip.nat_inside, interface__in=interfaces
-                #     ).exists()
-                # ):
-                #     raise ValidationError(
-                #         {f"{field}": f"The specified IP address ({ip}) is not assigned to this Virtual Device Context."}
-                #     )
 
     def clean(self):
         super().clean()

nautobot/dcim/navigation.py

@@ -4,11 +4,13 @@ from nautobot.core.apps import (
     NavMenuItem,
     NavMenuTab,
 )
+from nautobot.core.ui.choices import NavigationIconChoices, NavigationWeightChoices
 
 menu_items = (
     NavMenuTab(
         name="Organization",
-        weight=100,
+        icon=NavigationIconChoices.ORGANIZATION,
+        weight=NavigationWeightChoices.ORGANIZATION,
         groups=(
             NavMenuGroup(
                 name="Locations",
@@ -115,7 +117,8 @@ menu_items = (
     ),
     NavMenuTab(
         name="Devices",
-        weight=200,
+        icon=NavigationIconChoices.DEVICES,
+        weight=NavigationWeightChoices.DEVICES,
         groups=(
             NavMenuGroup(
                 name="Devices",
@@ -547,7 +550,8 @@ menu_items = (
     ),
     NavMenuTab(
         name="Power",
-        weight=600,
+        icon=NavigationIconChoices.POWER,
+        weight=NavigationWeightChoices.POWER,
         groups=(
             NavMenuGroup(
                 name="Power",

nautobot/dcim/querysets.py

@@ -0,0 +1,6 @@
+from nautobot.core.models.querysets import ClusterToClustersQuerySetMixin
+from nautobot.extras.querysets import ConfigContextModelQuerySet
+
+
+class DeviceQuerySet(ClusterToClustersQuerySetMixin, ConfigContextModelQuerySet):
+    pass

nautobot/dcim/signals.py

@@ -381,3 +381,22 @@ def content_type_changed(instance, action, **kwargs):
                     )
                 }
             )
+
+
+#
+# Device/Cluster assignments
+#
+
+
+@receiver(m2m_changed, sender=Device.clusters.through)
+def ensure_device_and_cluster_locations_are_compatible(sender, instance, action, pk_set, **kwargs):
+    """
+    When adding clusters to a device, clean the added DeviceClusterAssignment records to enforce location compatibility.
+    """
+    if action == "post_add" and pk_set:
+        if isinstance(instance, Device):
+            for assignment in instance.cluster_assignments.filter(cluster_id__in=pk_set):
+                assignment.clean()
+        else:  # instance is a Cluster
+            for assignment in instance.device_assignments.filter(device_id__in=pk_set):
+                assignment.clean()