nautobot 3.0.0a2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/vpn/api/views.py

@@ -0,0 +1,70 @@
+"""API views for the vpn models."""
+
+from nautobot.apps.api import ModelViewSet, NautobotModelViewSet
+
+from .. import filters, models
+from ..api import serializers
+
+
+class VPNProfileViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfile viewset."""
+
+    queryset = models.VPNProfile.objects.all()
+    serializer_class = serializers.VPNProfileSerializer
+    filterset_class = filters.VPNProfileFilterSet
+
+
+class VPNPhase1PolicyViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNPhase1Policy viewset."""
+
+    queryset = models.VPNPhase1Policy.objects.all()
+    serializer_class = serializers.VPNPhase1PolicySerializer
+    filterset_class = filters.VPNPhase1PolicyFilterSet
+
+
+class VPNPhase2PolicyViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNPhase2Policy viewset."""
+
+    queryset = models.VPNPhase2Policy.objects.all()
+    serializer_class = serializers.VPNPhase2PolicySerializer
+    filterset_class = filters.VPNPhase2PolicyFilterSet
+
+
+class VPNProfilePhase1PolicyAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfilePhase1PolicyAssignment viewset."""
+
+    queryset = models.VPNProfilePhase1PolicyAssignment.objects.all()
+    serializer_class = serializers.VPNProfilePhase1PolicyAssignmentSerializer
+    filterset_class = filters.VPNProfilePhase1PolicyAssignmentFilterSet
+
+
+class VPNProfilePhase2PolicyAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNProfilePhase2PolicyAssignment viewset."""
+
+    queryset = models.VPNProfilePhase2PolicyAssignment.objects.all()
+    serializer_class = serializers.VPNProfilePhase2PolicyAssignmentSerializer
+    filterset_class = filters.VPNProfilePhase2PolicyAssignmentFilterSet
+
+
+class VPNViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPN viewset."""
+
+    queryset = models.VPN.objects.all()
+    serializer_class = serializers.VPNSerializer
+    filterset_class = filters.VPNFilterSet
+
+
+class VPNTunnelViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNTunnel viewset."""
+
+    queryset = models.VPNTunnel.objects.all()
+    serializer_class = serializers.VPNTunnelSerializer
+    filterset_class = filters.VPNTunnelFilterSet
+
+
+class VPNTunnelEndpointViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VPNTunnelEndpoint viewset."""
+
+    queryset = models.VPNTunnelEndpoint.objects.all()
+    serializer_class = serializers.VPNTunnelEndpointSerializer
+    filterset_class = filters.VPNTunnelEndpointFilterSet

nautobot/vpn/apps.py

@@ -0,0 +1,8 @@
+from nautobot.core.apps import NautobotConfig
+
+
+class VPNConfig(NautobotConfig):
+    default = True
+    name = "nautobot.vpn"
+    verbose_name = "VPNs"
+    searchable_models = []

nautobot/vpn/choices.py

@@ -0,0 +1,171 @@
+"""Custom choices for the vpn models."""
+
+from nautobot.apps.choices import ChoiceSet
+
+
+class VPNTunnelStatusChoices(ChoiceSet):
+    STATUS_ACTIVE = "active"
+    STATUS_DOWN = "down"
+    STATUS_DEPRECATED = "deprecated"
+
+    CHOICES = (
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_DOWN, "Down"),
+        (STATUS_DEPRECATED, "Deprecated"),
+    )
+
+
+class VPNTunnelEndpointRoleChoices(ChoiceSet):
+    ROLE_PEER = "peer"
+    ROLE_HUB = "hub"
+    ROLE_SPOKE = "spoke"
+
+    CHOICES = (
+        (ROLE_PEER, "Peer"),
+        (ROLE_HUB, "Hub"),
+        (ROLE_SPOKE, "Spoke"),
+    )
+
+
+class IkeVersionChoices(ChoiceSet):
+    """Choices for the ike_version field on the VPNPhase1Policy model."""
+
+    ike_v1 = "IKEv1"
+    ike_v2 = "IKEv2"
+
+    CHOICES = (
+        (ike_v1, "IKEv1"),
+        (ike_v2, "IKEv2"),
+    )
+
+
+class EncryptionAlgorithmChoices(ChoiceSet):
+    """Choices for the encryption_algorithm field on the VPNPhase1Policy model."""
+
+    aes_128_cbc = "AES-128-CBC"
+    aes_128_gcm = "AES-128-GCM"
+    aes_192_cbc = "AES-192-CBC"
+    aes_192_gcm = "AES-192-GCM"
+    aes_256_cbc = "AES-256-CBC"
+    aes_256_gcm = "AES-256-GCM"
+    des = "DES"
+    a3des = "3DES"
+
+    CHOICES = (
+        (aes_128_cbc, "AES-128-CBC"),
+        (aes_128_gcm, "AES-128-GCM"),
+        (aes_192_cbc, "AES-192-CBC"),
+        (aes_192_gcm, "AES-192-GCM"),
+        (aes_256_cbc, "AES-256-CBC"),
+        (aes_256_gcm, "AES-256-GCM"),
+        (des, "DES"),
+        (a3des, "3DES"),
+    )
+
+
+class IntegrityAlgorithmChoices(ChoiceSet):
+    """Choices for the integrity_algorithm field on the VPNPhase1Policy model."""
+
+    md5 = "MD5"
+    sha1 = "SHA1"
+    sha256 = "SHA256"
+    sha384 = "SHA384"
+    sha512 = "SHA512"
+
+    CHOICES = (
+        (md5, "MD5"),
+        (sha1, "SHA1"),
+        (sha256, "SHA256"),
+        (sha384, "SHA384"),
+        (sha512, "SHA512"),
+    )
+
+
+class DhGroupChoices(ChoiceSet):
+    """Choices for the dh_group field on the VPNPhase1Policy model."""
+
+    group1 = "1"
+    group2 = "2"
+    group5 = "5"
+    group14 = "14"
+    group19 = "19"
+    group20 = "20"
+    group21 = "21"
+    group22 = "22"
+    group23 = "23"
+    group24 = "24"
+    group25 = "25"
+    group26 = "26"
+    group27 = "27"
+    group28 = "28"
+    group29 = "29"
+    group30 = "30"
+    group31 = "31"
+    group32 = "32"
+    group33 = "33"
+    group34 = "34"
+
+    CHOICES = (
+        (group1, "Group 1"),
+        (group2, "Group 2"),
+        (group5, "Group 5"),
+        (group14, "Group 14"),
+        (group19, "Group 19"),
+        (group20, "Group 20"),
+        (group21, "Group 21"),
+        (group22, "Group 22"),
+        (group23, "Group 23"),
+        (group24, "Group 24"),
+        (group25, "Group 25"),
+        (group26, "Group 26"),
+        (group27, "Group 27"),
+        (group28, "Group 28"),
+        (group29, "Group 29"),
+        (group30, "Group 30"),
+        (group31, "Group 31"),
+        (group32, "Group 32"),
+        (group33, "Group 33"),
+        (group34, "Group 34"),
+    )
+
+
+class AuthenticationMethodChoices(ChoiceSet):
+    """Choices for the authentication_method field on the VPNPhase1Policy model."""
+
+    psk = "PSK"
+    rsa = "RSA"
+    ecdsa = "ECDSA"
+    certificate = "Certificate"
+
+    CHOICES = (
+        (psk, "PSK"),
+        (rsa, "RSA"),
+        (ecdsa, "ECDSA"),
+        (certificate, "Certificate"),
+    )
+
+
+class EncapsulationChoices(ChoiceSet):
+    """Choices for the encapsulation field on the VPNTunnel model."""
+
+    ipsec_transport = "IPsec-Transport"
+    ipsec_tunnel = "IPsec-Tunnel"
+    ip_in_ip = "IP-in-IP"
+    gre = "GRE"
+    wireguard = "WireGuard"
+    l2tp = "L2TP"
+    pptp = "PPTP"
+    openvpn = "OpenVPN"
+    eoip = "EoIP"
+
+    CHOICES = (
+        (ipsec_transport, "IPsec-Transport"),
+        (ipsec_tunnel, "IPsec-Tunnel"),
+        (ip_in_ip, "IP-in-IP"),
+        (gre, "GRE"),
+        (wireguard, "WireGuard"),
+        (l2tp, "L2TP"),
+        (pptp, "PPTP"),
+        (openvpn, "OpenVPN"),
+        (eoip, "EoIP"),
+    )

nautobot/vpn/factory.py

@@ -0,0 +1,219 @@
+from django.contrib.contenttypes.models import ContentType
+import factory
+import faker
+
+from nautobot.core.factory import (
+    get_random_instances,
+    NautobotBoolIterator,
+    PrimaryModelFactory,
+    random_instance,
+    UniqueFaker,
+)
+from nautobot.dcim.models import Interface
+from nautobot.extras.models import DynamicGroup, Role, SecretsGroup, Status
+from nautobot.ipam.models import Prefix
+from nautobot.tenancy.models import Tenant
+from nautobot.vpn import choices, models
+
+
+class VPNPhase1PolicyFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNPhase1Policy
+        exclude = ("has_description", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    ike_version = factory.Faker("random_element", elements=choices.IkeVersionChoices.values())
+    encryption_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.EncryptionAlgorithmChoices.values(), unique=True))
+    )
+    integrity_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.IntegrityAlgorithmChoices.values(), unique=True))
+    )
+    dh_group = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.DhGroupChoices.values(), unique=True))
+    )
+    lifetime_seconds = factory.Faker("pyint", min_value=0, max_value=3600, step=15)
+    lifetime_kb = factory.Faker("pyint", min_value=0, max_value=1024)
+    authentication_method = factory.Faker("random_element", elements=choices.AuthenticationMethodChoices.values())
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNPhase2PolicyFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNPhase2Policy
+        exclude = ("has_description", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    encryption_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.EncryptionAlgorithmChoices.values(), unique=True))
+    )
+    integrity_algorithm = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.IntegrityAlgorithmChoices.values(), unique=True))
+    )
+    pfs_group = factory.LazyFunction(
+        lambda: sorted(faker.Faker().random_elements(choices.DhGroupChoices.values(), unique=True))
+    )
+    lifetime = factory.Faker("pyint", min_value=0, max_value=3600, step=15)
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNProfileFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNProfile
+        exclude = ("has_description", "has_role", "has_secrets_group", "has_extra_options", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNProfile), allow_null=True),
+        None,
+    )
+    has_secrets_group = NautobotBoolIterator()
+    secrets_group = factory.Maybe(
+        "has_secrets_group",
+        random_instance(SecretsGroup),
+    )
+    keepalive_enabled = NautobotBoolIterator()
+    keepalive_interval = factory.Faker("pyint", min_value=0, max_value=3600, step=3)
+    keepalive_retries = factory.Faker("pyint", min_value=0, max_value=180, step=3)
+    nat_traversal = NautobotBoolIterator()
+    has_extra_options = NautobotBoolIterator()
+    extra_options = factory.Maybe(
+        "has_extra_options", factory.Faker("pydict", nb_elements=2, value_types=[str, bool, int]), None
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+    @factory.post_generation
+    def vpn_phase1_policies(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.vpn_phase1_policies.set(extracted)
+            else:
+                self.vpn_phase1_policies.set(get_random_instances(models.VPNPhase1Policy, minimum=1))
+
+    @factory.post_generation
+    def vpn_phase2_policies(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.vpn_phase2_policies.set(extracted)
+            else:
+                self.vpn_phase2_policies.set(get_random_instances(models.VPNPhase2Policy, minimum=1))
+
+
+class VPNFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPN
+        exclude = ("has_description", "has_profile", "has_role", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    vpn_id = factory.Faker("word")
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPN), allow_null=True),
+        None,
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNTunnelFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNTunnel
+        exclude = ("has_description", "has_profile", "has_vpn", "has_role", "has_tenant")
+
+    name = UniqueFaker("word")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    tunnel_id = factory.Faker("word")
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_vpn = NautobotBoolIterator()
+    vpn = factory.Maybe("has_vpn", random_instance(models.VPN), None)
+    status = random_instance(
+        lambda: Status.objects.get_for_model(models.VPNTunnel),
+        allow_null=False,
+    )
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNTunnel), allow_null=True),
+        None,
+    )
+    encapsulation = factory.Faker("random_element", elements=choices.EncapsulationChoices.values())
+    endpoint_a = factory.Sequence(lambda n: models.VPNTunnelEndpoint.objects.all()[n])
+    endpoint_z = factory.Sequence(lambda n: models.VPNTunnelEndpoint.objects.all()[n + 10])
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+
+class VPNTunnelEndpointFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.VPNTunnelEndpoint
+        exclude = ("has_source_interface", "has_profile", "has_role", "has_tenant")
+
+    has_source_interface = NautobotBoolIterator()
+    source_interface = factory.Maybe(
+        "has_source_interface",
+        random_instance(
+            lambda: Interface.objects.filter(vpn_tunnel_endpoints_src_int__isnull=True, device__isnull=False)
+        ),
+        None,
+    )
+    source_fqdn = factory.Maybe("has_source_interface", "", factory.Faker("hostname"))
+
+    @factory.lazy_attribute
+    def tunnel_interface(self):
+        """Filter tunnel interfaces on the same device as source_interface."""
+        if self.has_source_interface:
+            qs = Interface.objects.filter(type="tunnel", device=self.source_interface.device)
+            return factory.random.randgen.choice(qs) if qs.exists() else None
+        return None
+
+    has_profile = NautobotBoolIterator()
+    vpn_profile = factory.Maybe("has_profile", random_instance(models.VPNProfile), None)
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(models.VPNTunnelEndpoint), allow_null=True),
+        None,
+    )
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant), None)
+
+    @factory.post_generation
+    def protected_prefixes(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.protected_prefixes.set(extracted)
+            else:
+                # TODO Investigate https://github.com/nautobot/nautobot/actions/runs/11019738391/job/30603271529
+                # to uncomment the line below.
+                # self.protected_prefixes.set(get_random_instances(Prefix))
+                self.protected_prefixes.set(get_random_instances(model_or_queryset_or_lambda=Prefix, maximum=1))
+
+    @factory.post_generation
+    def protected_prefixes_dg(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.protected_prefixes_dg.set(extracted)
+            else:
+                self.protected_prefixes_dg.set(
+                    get_random_instances(
+                        DynamicGroup.objects.filter(content_type=ContentType.objects.get_for_model(Prefix)), minimum=0
+                    )
+                )

nautobot/vpn/filters.py

@@ -0,0 +1,234 @@
+"""Filtering for the vpn models."""
+
+from nautobot.apps.filters import (
+    BaseFilterSet,
+    NaturalKeyOrPKMultipleChoiceFilter,
+    NautobotFilterSet,
+    SearchFilter,
+    StatusModelFilterSetMixin,
+    TenancyModelFilterSetMixin,
+)
+from nautobot.dcim.models import Device, Interface
+from nautobot.ipam.models import IPAddress
+
+from . import models
+
+
+class VPNProfileFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPNProfile."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+        }
+    )
+    vpn_phase1_policies = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNPhase1Policy.objects.all(),
+        to_field_name="name",
+        label="Phase 1 Policy (name or ID)",
+    )
+    vpn_phase2_policies = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNPhase2Policy.objects.all(),
+        to_field_name="name",
+        label="Phase 2 Policy (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPNProfile
+        fields = "__all__"
+
+
+class VPNPhase1PolicyFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPNPhase1Policy."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+        }
+    )
+    vpn_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        to_field_name="name",
+        label="VPN Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPNPhase1Policy
+        fields = "__all__"
+
+
+class VPNPhase2PolicyFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPNPhase2Policy."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+        }
+    )
+    vpn_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        to_field_name="name",
+        label="VPN Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPNPhase2Policy
+        fields = "__all__"
+
+
+class VPNProfilePhase1PolicyAssignmentFilterSet(BaseFilterSet):
+    """Filterset for the VPNProfilePhase1PolicyAssignment through model."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "vpn_profile__name": "icontains",
+            "vpn_phase1_policy__name": "icontains",
+        },
+    )
+
+    vpn_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        label="VPN Profile (name or ID)",
+        to_field_name="name",
+    )
+    vpn_phase1_policy = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNPhase1Policy.objects.all(),
+        label="Phase 1 Policy (name or ID)",
+        to_field_name="name",
+    )
+
+    class Meta:
+        model = models.VPNProfilePhase1PolicyAssignment
+        fields = "__all__"
+
+
+class VPNProfilePhase2PolicyAssignmentFilterSet(BaseFilterSet):
+    """Filterset for the VPNProfilePhase2PolicyAssignment through model."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "vpn_profile__name": "icontains",
+            "vpn_phase2_policy__name": "icontains",
+        },
+    )
+
+    vpn_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        label="VPN Profile (name or ID)",
+        to_field_name="name",
+    )
+    vpn_phase2_policy = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNPhase2Policy.objects.all(),
+        label="Phase 2 Policy (name or ID)",
+        to_field_name="name",
+    )
+
+    class Meta:
+        model = models.VPNProfilePhase2PolicyAssignment
+        fields = "__all__"
+
+
+class VPNFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPN."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "vpn_id": "icontains",
+        }
+    )
+    vpn_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        label="VPN Profile (name or ID)",
+        to_field_name="name",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPN
+        fields = "__all__"
+
+
+class VPNTunnelFilterSet(StatusModelFilterSetMixin, TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPNTunnel."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "tunnel_id": "icontains",
+        }
+    )
+    vpn_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNProfile.objects.all(),
+        label="VPN Profile (name or ID)",
+        to_field_name="name",
+    )
+    vpn = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPN.objects.all(),
+        label="VPN (name or ID)",
+        to_field_name="name",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPNTunnel
+        fields = "__all__"
+
+
+class VPNTunnelEndpointFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VPNTunnelEndpoint."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "source_fqdn": "icontains",
+            "device__name": "icontains",
+        }
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        to_field_name="name",
+        label="Device (ID or name)",
+    )
+    source_interface = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Interface.objects.all(),
+        to_field_name="name",
+        label="Source Interface (ID or name)",
+    )
+    source_ipaddress = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=IPAddress.objects.all(),
+        to_field_name="name",
+        label="Source IPAddress (ID or name)",
+    )
+    tunnel_interface = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Interface.objects.filter(type="tunnel"),
+        to_field_name="name",
+        label="Tunnel Interface (ID or name)",
+    )
+    endpoint_a_vpn_tunnels = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNTunnel.objects.all(),
+        to_field_name="name",
+        label="Endpoint A",
+    )
+    endpoint_z_vpn_tunnels = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VPNTunnel.objects.all(),
+        to_field_name="name",
+        label="Endpoint Z",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VPNTunnelEndpoint
+        fields = "__all__"