nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/ipam/filters.py

@@ -19,10 +19,10 @@ from nautobot.core.filters import (
     TreeNodeMultipleChoiceFilter,
 )
 from nautobot.dcim.filters import LocatableModelFilterSetMixin
-from nautobot.dcim.models import Device, Interface, Location
+from nautobot.dcim.models import Device, Interface, Location, VirtualDeviceContext
 from nautobot.extras.filters import NautobotFilterSet, RoleModelFilterSetMixin, StatusModelFilterSetMixin
-from nautobot.ipam import choices
-from nautobot.tenancy.filters import TenancyModelFilterSetMixin
+from nautobot.ipam import choices, formfields
+from nautobot.tenancy.filters.mixins import TenancyModelFilterSetMixin
 from nautobot.virtualization.models import VirtualMachine, VMInterface
 
 from .models import (
@@ -45,6 +45,7 @@ from .models import (
 __all__ = (
     "IPAddressFilterSet",
     "NamespaceFilterSet",
+    "PrefixFilter",
     "PrefixFilterSet",
     "RIRFilterSet",
     "RouteTargetFilterSet",
@@ -55,6 +56,39 @@ __all__ = (
 )
 
 
+class PrefixFilter(NaturalKeyOrPKMultipleChoiceFilter):
+    """
+    Filter that supports filtering a foreign key to Prefix by either its PK or by a literal `prefix` string.
+    """
+
+    field_class = formfields.PrefixFilterFormField
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("to_field_name", "pk")
+        kwargs.setdefault("label", "Prefix (ID or prefix string)")
+        kwargs.setdefault("queryset", Prefix.objects.all())
+        super().__init__(*args, **kwargs)
+
+    def get_filter_predicate(self, v):
+        # Null value filtering
+        if v is None:
+            return {f"{self.field_name}__isnull": True}
+
+        # If value is a model instance, stringify it to a pk.
+        if isinstance(v, Prefix):
+            v = v.pk
+
+        # Try to cast the value to a UUID to distinguish between PKs and prefix strings
+        v = str(v)
+        try:
+            uuid.UUID(v)
+            return {self.field_name: v}
+        except (AttributeError, TypeError, ValueError):
+            # It's a prefix string
+            prefixes_queryset = Prefix.objects.net_equals(v)
+            return {f"{self.field_name}__in": prefixes_queryset.values_list("pk", flat=True)}
+
+
 class NamespaceFilterSet(NautobotFilterSet):
     q = SearchFilter(
         filter_predicates={
@@ -96,12 +130,7 @@ class VRFFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyModelFil
         to_field_name="name",
         label="Virtual Machine (ID or name)",
     )
-    prefix = NaturalKeyOrPKMultipleChoiceFilter(
-        field_name="prefixes",
-        queryset=Prefix.objects.all(),
-        to_field_name="pk",  # TODO: Make this work with `prefix` "somehow"
-        label="Prefix (ID or name)",
-    )
+    prefix = PrefixFilter(field_name="prefixes")
     namespace = NaturalKeyOrPKMultipleChoiceFilter(
         queryset=Namespace.objects.all(),
         to_field_name="name",
@@ -114,6 +143,21 @@ class VRFFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyModelFil
 
 
 class VRFDeviceAssignmentFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "vrf__name": "icontains",
+            "device__name": "icontains",
+            "virtual_machine__name": "icontains",
+            "virtual_device_context__name": "icontains",
+            "rd": "icontains",
+        },
+    )
+    vrf = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VRF.objects.all(),
+        to_field_name="name",
+        label="VRF (ID or name)",
+    )
     device = NaturalKeyOrPKMultipleChoiceFilter(
         queryset=Device.objects.all(),
         to_field_name="name",
@@ -124,18 +168,25 @@ class VRFDeviceAssignmentFilterSet(NautobotFilterSet):
         to_field_name="name",
         label="Virtual Machine (ID or name)",
     )
+    virtual_device_context = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualDeviceContext.objects.all(),
+        to_field_name="name",
+        label="Virtual Device Context (ID or name)",
+    )
 
     class Meta:
         model = VRFDeviceAssignment
-        fields = ["id", "vrf", "device", "virtual_machine"]
+        fields = ["id", "name", "rd"]
 
 
 class VRFPrefixAssignmentFilterSet(NautobotFilterSet):
-    prefix = NaturalKeyOrPKMultipleChoiceFilter(
-        queryset=Prefix.objects.all(),
-        to_field_name="pk",  # TODO: Make this work with `prefix` "somehow"
-        label="Prefix (ID or name)",
+    q = SearchFilter(
+        filter_predicates={
+            # "prefix__prefix": "iexact",  # TODO?
+            "vrf__name": "icontains",
+        },
     )
+    prefix = PrefixFilter()
     vrf = NaturalKeyOrPKMultipleChoiceFilter(
         queryset=VRF.objects.all(),
         to_field_name="name",
@@ -200,10 +251,7 @@ class PrefixFilterSet(
     StatusModelFilterSetMixin,
     RoleModelFilterSetMixin,
 ):
-    # Prefix doesn't have an appropriate single natural-key field for a NaturalKeyOrPKMultipleChoiceFilter
-    parent = django_filters.ModelMultipleChoiceFilter(
-        queryset=Prefix.objects.all(),
-    )
+    parent = PrefixFilter()
     prefix = MultiValueCharFilter(
         method="filter_prefix",
         label="Prefix",
@@ -343,10 +391,7 @@ class PrefixLocationAssignmentFilterSet(NautobotFilterSet):
             "location__name": "icontains",
         },
     )
-    prefix = MultiValueCharFilter(
-        method="filter_prefix",
-        label="Prefix",
-    )
+    prefix = PrefixFilter()
     location = TreeNodeMultipleChoiceFilter(
         prefers_id=True,
         queryset=Location.objects.all(),
@@ -357,13 +402,6 @@ class PrefixLocationAssignmentFilterSet(NautobotFilterSet):
     def _strip_values(self, values):
         return [value.strip() for value in values if value.strip()]
 
-    def filter_prefix(self, queryset, name, value):
-        prefixes = self._strip_values(value)
-        with contextlib.suppress(netaddr.AddrFormatError, ValueError):
-            prefixes_queryset = Prefix.objects.net_equals(*prefixes)
-            return queryset.filter(prefix__in=prefixes_queryset)
-        return queryset.none()
-
     class Meta:
         model = PrefixLocationAssignment
         fields = ["id", "prefix", "location"]

nautobot/ipam/formfields.py

@@ -1,8 +1,12 @@
 from django import forms
 from django.core.exceptions import ValidationError
 from django.core.validators import validate_ipv4_address, validate_ipv6_address
+from django.db.models import Q
 from netaddr import AddrFormatError, IPAddress, IPNetwork
 
+from nautobot.core.forms.fields import MultiMatchModelMultipleChoiceField
+from nautobot.core.utils.data import is_uuid
+
 #
 # Form fields
 #
@@ -58,3 +62,50 @@ class IPNetworkFormField(forms.Field):
             return IPNetwork(value)
         except AddrFormatError:
             raise ValidationError("Please specify a valid IPv4 or IPv6 address.")
+
+
+class PrefixFilterFormField(MultiMatchModelMultipleChoiceField):
+    @property
+    def filter(self):
+        from nautobot.ipam.filters import PrefixFilter  # avoid circular definition
+
+        return PrefixFilter
+
+    def _check_values(self, values):  # pylint: disable=arguments-renamed
+        null_value_present = self.null_label is not None and values and self.null_value in values
+        if null_value_present:
+            values = [v for v in values if v != self.null_value]
+        # deduplicate given values to avoid creating many querysets or
+        # requiring the database backend deduplicate efficiently.
+        try:
+            values = frozenset(values)
+        except TypeError:
+            raise ValidationError(self.error_messages["invalid_list"], code="invalid_list")
+        pk_values = set()
+        prefix_queries = []
+        for value in values:
+            if is_uuid(value):
+                pk_values.add(value)
+                query = Q(pk=value)
+            else:
+                ipnetwork = IPNetwork(value)
+                query = Q(
+                    network=ipnetwork.network,
+                    prefix_length=ipnetwork.prefixlen,
+                    broadcast=ipnetwork.broadcast or ipnetwork[-1],
+                )
+                prefix_queries.append(query)
+            if not self.queryset.filter(query).exists():
+                raise ValidationError(
+                    self.error_messages["invalid_choice"],
+                    code="invalid_choice",
+                    params={"value": value},
+                )
+        aggregate_query = Q(pk__in=pk_values)
+        for prefix_query in prefix_queries:
+            aggregate_query |= prefix_query
+        qs = self.queryset.filter(aggregate_query)
+        result = list(qs)
+        if null_value_present:
+            result.append(self.null_value)
+        return result

nautobot/ipam/forms.py

@@ -23,7 +23,7 @@ from nautobot.dcim.form_mixins import (
     LocatableModelFilterFormMixin,
     LocatableModelFormMixin,
 )
-from nautobot.dcim.models import Device, Location, Rack
+from nautobot.dcim.models import Device, Location, Rack, VirtualDeviceContext
 from nautobot.extras.forms import (
     NautobotBulkEditForm,
     NautobotFilterForm,
@@ -111,6 +111,9 @@ class VRFForm(NautobotModelForm, TenancyForm):
     namespace = DynamicModelChoiceField(queryset=Namespace.objects.all())
     devices = DynamicModelMultipleChoiceField(queryset=Device.objects.all(), required=False)
     virtual_machines = DynamicModelMultipleChoiceField(queryset=VirtualMachine.objects.all(), required=False)
+    virtual_device_contexts = DynamicModelMultipleChoiceField(
+        queryset=VirtualDeviceContext.objects.all(), required=False
+    )
     prefixes = DynamicModelMultipleChoiceField(
         queryset=Prefix.objects.all(),
         required=False,
@@ -134,6 +137,7 @@ class VRFForm(NautobotModelForm, TenancyForm):
             "tags",
             "devices",
             "virtual_machines",
+            "virtual_device_contexts",
             "prefixes",
         ]
         labels = {
@@ -156,6 +160,14 @@ class VRFBulkEditForm(TagsBulkEditFormMixin, StatusModelBulkEditFormMixin, Nauto
     remove_prefixes = DynamicModelMultipleChoiceField(
         queryset=Prefix.objects.all(), required=False, query_params={"namespace": "$namespace"}
     )
+    add_virtual_device_contexts = DynamicModelMultipleChoiceField(
+        queryset=VirtualDeviceContext.objects.all(),
+        required=False,
+    )
+    remove_virtual_device_contexts = DynamicModelMultipleChoiceField(
+        queryset=VirtualDeviceContext.objects.all(),
+        required=False,
+    )
 
     class Meta:
         nullable_fields = [
@@ -250,6 +262,21 @@ class RIRFilterForm(NautobotFilterForm):
     )
 
 
+class RIRBulkEditForm(NautobotBulkEditForm):
+    pk = forms.ModelMultipleChoiceField(queryset=RIR.objects.all(), widget=forms.MultipleHiddenInput())
+    is_private = forms.NullBooleanField(
+        required=False,
+        label="Private",
+        widget=StaticSelect2(choices=BOOLEAN_WITH_BLANK_CHOICES),
+    )
+    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
+
+    class Meta:
+        nullable_fields = [
+            "description",
+        ]
+
+
 #
 # Prefixes
 #

nautobot/ipam/migrations/0051_added_optional_vrf_relationship_to_vdc.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2.19 on 2025-02-24 21:20
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("virtualization", "0030_alter_virtualmachine_local_config_context_data_owner_content_type_and_more"),
+        ("dcim", "0067_controllermanageddevicegroup_tenant"),
+        ("ipam", "0050_vlangroup_range"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="vrf",
+            name="virtual_device_contexts",
+            field=models.ManyToManyField(
+                related_name="vrfs", through="ipam.VRFDeviceAssignment", to="dcim.virtualdevicecontext"
+            ),
+        ),
+        migrations.AddField(
+            model_name="vrfdeviceassignment",
+            name="virtual_device_context",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="vrf_assignments",
+                to="dcim.virtualdevicecontext",
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="vrfdeviceassignment",
+            unique_together={
+                ("vrf", "virtual_device_context"),
+                ("vrf", "virtual_machine"),
+                ("vrf", "device"),
+            },
+        ),
+    ]

nautobot/ipam/models.py

@@ -135,6 +135,12 @@ class VRF(PrimaryModel):
         through="ipam.VRFDeviceAssignment",
         through_fields=("vrf", "virtual_machine"),
     )
+    virtual_device_contexts = models.ManyToManyField(
+        to="dcim.VirtualDeviceContext",
+        related_name="vrfs",
+        through="ipam.VRFDeviceAssignment",
+        through_fields=("vrf", "virtual_device_context"),
+    )
     prefixes = models.ManyToManyField(
         to="ipam.Prefix",
         related_name="vrfs",
@@ -238,6 +244,41 @@ class VRF(PrimaryModel):
         instance = self.virtual_machines.through.objects.get(vrf=self, virtual_machine=virtual_machine)
         return instance.delete()
 
+    def add_virtual_device_context(self, virtual_device_context, rd="", name=""):
+        """
+        Add a `virtual_device_context` to this VRF, optionally overloading `rd` and `name`.
+
+        If `rd` or `name` are not provided, the values from this VRF will be inherited.
+
+        Args:
+            virtual_device_context (VirtualDeviceContext): VirtualDeviceContext instance
+            rd (str): (Optional) RD of the VRF when associated with this VirtualDeviceContext
+            name (str): (Optional) Name of the VRF when associated with this VirtualDeviceContext
+
+        Returns:
+            VRFDeviceAssignment instance
+        """
+        instance = self.virtual_device_contexts.through(
+            vrf=self, virtual_device_context=virtual_device_context, rd=rd, name=name
+        )
+        instance.validated_save()
+        return instance
+
+    def remove_virtual_device_context(self, virtual_device_context):
+        """
+        Remove a `virtual_device_context` from this VRF.
+
+        Args:
+            virtual_device_context (VirtualDeviceContext): VirtualDeviceContext instance
+
+        Returns:
+            tuple (int, dict): Number of objects deleted and a dict with number of deletions.
+        """
+        instance = self.virtual_device_contexts.through.objects.get(
+            vrf=self, virtual_device_context=virtual_device_context
+        )
+        return instance.delete()
+
     def add_prefix(self, prefix):
         """
         Add a `prefix` to this VRF. Each object must be in the same Namespace.
@@ -275,6 +316,9 @@ class VRFDeviceAssignment(BaseModel):
     virtual_machine = models.ForeignKey(
         "virtualization.VirtualMachine", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
     )
+    virtual_device_context = models.ForeignKey(
+        "dcim.VirtualDeviceContext", null=True, blank=True, on_delete=models.CASCADE, related_name="vrf_assignments"
+    )
     rd = models.CharField(  # noqa: DJ001  # django-nullable-model-string-field -- see below
         max_length=constants.VRF_RD_MAX_LENGTH,
         blank=True,
@@ -289,14 +333,16 @@ class VRFDeviceAssignment(BaseModel):
         unique_together = [
             ["vrf", "device"],
             ["vrf", "virtual_machine"],
+            ["vrf", "virtual_device_context"],
             # TODO: desirable in the future, but too strict for 1.x-to-2.0 data migrations,
             #       as multiple "cleanup" VRFs in different cleanup namespaces might be assigned to a single device/VM.
             # ["device", "rd", "name"],
             # ["virtual_machine", "rd", "name"],
+            # ["virtual_device_context", "rd", "name"],
         ]
 
     def __str__(self):
-        obj = self.device or self.virtual_machine
+        obj = self.device or self.virtual_machine or self.virtual_device_context
         return f"{self.vrf} [{obj}] (rd: {self.rd}, name: {self.name})"
 
     def clean(self):
@@ -310,11 +356,23 @@ class VRFDeviceAssignment(BaseModel):
         if not self.name:
             self.name = self.vrf.name
 
-        # A VRF must belong to a Device *or* to a VirtualMachine.
+        # A VRF must belong to a Device *or* to a VirtualMachine *or* to a Virtual Device Context.
         if all([self.device, self.virtual_machine]):
-            raise ValidationError("A VRF cannot be associated with both a device and a virtual machine.")
-        if not any([self.device, self.virtual_machine]):
-            raise ValidationError("A VRF must be associated with either a device or a virtual machine.")
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual machine."
+            )
+        if all([self.device, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual device context."
+            )
+        if all([self.virtual_machine, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry cannot be associated with both a virtual machine and a virtual device context."
+            )
+        if not any([self.device, self.virtual_machine, self.virtual_device_context]):
+            raise ValidationError(
+                "A VRFDeviceAssignment entry must be associated with a device, a virtual machine, or a virtual device context."
+            )
 
 
 @extras_features("graphql")

nautobot/ipam/querysets.py

@@ -405,6 +405,12 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
         namespace = kwargs.pop("namespace", None)
         host = kwargs.get("host")
         mask_length = kwargs.get("mask_length")
+        address = kwargs.get("address")
+        if host is None and address is not None:
+            address = netaddr.IPNetwork(address)
+            host = str(address.ip)
+            mask_length = address.prefixlen
+
         # If `host` or `mask_length` is None skip; then there is no way of getting the closest parent;
         if parent is None and host is not None and mask_length is not None:
             if namespace is None:

nautobot/ipam/tables.py

@@ -247,13 +247,27 @@ class VRFDeviceAssignmentTable(BaseTable):
         linkify=lambda record: record.vrf.namespace.get_absolute_url(),
         accessor="vrf.namespace.name",
     )
-    device = tables.Column(
-        linkify=lambda record: record.device.get_absolute_url(), accessor="device.name", verbose_name="Device"
+    related_object_type = tables.TemplateColumn(
+        template_code="""
+        {% if record.device %}
+            Device
+        {% elif record.virtual_machine %}
+            Virtual Machine
+        {% else %}
+            Virtual Device Context
+        {% endif %}
+        """
     )
-    virtual_machine = tables.Column(
-        linkify=lambda record: record.virtual_machine.get_absolute_url(),
-        accessor="virtual_machine.name",
-        verbose_name="Virtual Machine",
+    related_object_name = tables.TemplateColumn(
+        template_code="""
+        {% if record.device %}
+            <a href="{{ record.device.get_absolute_url }}">{{ record.device.name }}</a>
+        {% elif record.virtual_machine %}
+            <a href="{{ record.virtual_machine.get_absolute_url }}">{{ record.virtual_machine.name }}</a>
+        {% else %}
+            <a href="{{ record.virtual_device_context.get_absolute_url }}">{{ record.virtual_device_context.name }}</a>
+        {% endif %}
+        """
     )
     rd = tables.Column(verbose_name="VRF RD")
     tenant = TenantColumn(accessor="vrf.tenant")
@@ -261,7 +275,7 @@ class VRFDeviceAssignmentTable(BaseTable):
     class Meta(BaseTable.Meta):
         model = VRFDeviceAssignment
         orderable = False
-        fields = ("vrf", "namespace", "device", "virtual_machine", "rd", "tenant")
+        fields = ("vrf", "related_object_type", "related_object_name", "namespace", "rd", "tenant")
 
 
 class VRFPrefixAssignmentTable(BaseTable):

nautobot/ipam/templates/ipam/rir.html

@@ -1,44 +1,2 @@
 {% extends 'generic/object_retrieve.html' %}
-{% load helpers %}
-
-{% block content_left_page %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>RIR</strong>
-            </div>
-            <table class="table table-hover panel-body attr-table">
-                <tr>
-                    <td>Description</td>
-                    <td>{{ object.description|placeholder }}</td>
-                </tr>
-                <tr>
-                    <td>Private</td>
-                    <td>{{ object.is_private | render_boolean }}</td>
-                </tr>
-                <tr>
-                    <td>Assigned Prefixes</td>
-                    <td>
-                        <a href="{% url 'ipam:prefix_list' %}?rir={{ object.name }}">{{ assigned_prefix_table.rows|length }}</a>
-                    </td>
-                </tr>
-            </table>
-        </div>
-{% endblock content_left_page %}
-
-{% block content_full_width_page %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Assigned Prefixes</strong>
-            </div>
-            {% include 'inc/table.html' with table=assigned_prefix_table %}
-            {% if perms.ipam.add_prefix %}
-                <div class="panel-footer text-right noprint">
-                    <a href="{% url 'ipam:prefix_add' %}?rir={{ object.pk }}" class="btn btn-xs btn-primary">
-                        <span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add prefix
-                    </a>
-                </div>
-            {% endif %}
-        </div>
-        {% include 'inc/paginator.html' with paginator=assigned_prefix_table.paginator page=assigned_prefix_table.page %}
-        <div class="row"></div>
-{% endblock content_full_width_page %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}