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

nautobot/load_balancers/api/urls.py

@@ -0,0 +1,23 @@
+"""Django API urlpatterns declaration for nautobot_load_balancer_models app."""
+
+from nautobot.core.api.routers import OrderedDefaultRouter
+
+from . import views
+
+router = OrderedDefaultRouter(view_name="Load Balancers")
+
+router.register("certificate-profiles", views.CertificateProfileViewSet)
+router.register("health-check-monitors", views.HealthCheckMonitorViewSet)
+router.register("load-balancer-pool-members", views.LoadBalancerPoolMemberViewSet)
+router.register(
+    "load-balancer-pool-member-certificate-profile-assignments",
+    views.LoadBalancerPoolMemberCertificateProfileAssignmentViewSet,
+)
+router.register("load-balancer-pools", views.LoadBalancerPoolViewSet)
+router.register("virtual-servers", views.VirtualServerViewSet)
+router.register(
+    "virtual-server-certificate-profile-assignments", views.VirtualServerCertificateProfileAssignmentViewSet
+)
+
+app_name = "load_balancers-api"
+urlpatterns = router.urls

nautobot/load_balancers/api/views.py

@@ -0,0 +1,61 @@
+"""API views for nautobot_load_balancer_models."""
+
+from nautobot.extras.api.views import ModelViewSet, NautobotModelViewSet
+from nautobot.load_balancers import filters, models
+from nautobot.load_balancers.api import serializers
+
+
+class VirtualServerViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """VirtualServer viewset."""
+
+    queryset = models.VirtualServer.objects.all()
+    serializer_class = serializers.VirtualServerSerializer
+    filterset_class = filters.VirtualServerFilterSet
+
+
+class LoadBalancerPoolViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """LoadBalancerPool viewset."""
+
+    queryset = models.LoadBalancerPool.objects.all()
+    serializer_class = serializers.LoadBalancerPoolSerializer
+    filterset_class = filters.LoadBalancerPoolFilterSet
+
+
+class LoadBalancerPoolMemberViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """LoadBalancerPoolMember viewset."""
+
+    queryset = models.LoadBalancerPoolMember.objects.all()
+    serializer_class = serializers.LoadBalancerPoolMemberSerializer
+    filterset_class = filters.LoadBalancerPoolMemberFilterSet
+
+
+class HealthCheckMonitorViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """HealthCheckMonitor viewset."""
+
+    queryset = models.HealthCheckMonitor.objects.all()
+    serializer_class = serializers.HealthCheckMonitorSerializer
+    filterset_class = filters.HealthCheckMonitorFilterSet
+
+
+class CertificateProfileViewSet(NautobotModelViewSet):  # pylint: disable=too-many-ancestors
+    """CertificateProfile viewset."""
+
+    queryset = models.CertificateProfile.objects.all()
+    serializer_class = serializers.CertificateProfileSerializer
+    filterset_class = filters.CertificateProfileFilterSet
+
+
+class VirtualServerCertificateProfileAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """VirtualServerCertificateProfileAssignment viewset."""
+
+    queryset = models.VirtualServerCertificateProfileAssignment.objects.all()
+    serializer_class = serializers.VirtualServerCertificateProfileAssignmentSerializer
+    filterset_class = filters.VirtualServerCertificateProfileAssignmentFilterSet
+
+
+class LoadBalancerPoolMemberCertificateProfileAssignmentViewSet(ModelViewSet):  # pylint: disable=too-many-ancestors
+    """LoadBalancerPoolMemberCertificateProfileAssignment viewset."""
+
+    queryset = models.LoadBalancerPoolMemberCertificateProfileAssignment.objects.all()
+    serializer_class = serializers.LoadBalancerPoolMemberCertificateProfileAssignmentSerializer
+    filterset_class = filters.LoadBalancerPoolMemberCertificateProfileAssignmentFilterSet

nautobot/load_balancers/apps.py

@@ -0,0 +1,17 @@
+from nautobot.core.apps import NautobotConfig
+
+
+class LoadBalancersConfig(NautobotConfig):
+    """App configuration for the nautobot_load_balancer_models app."""
+
+    default = True
+    name = "nautobot.load_balancers"
+    verbose_name = "Load Balancers"
+    base_url = "load-balancers"
+    searchable_models = [
+        "virtualserver",
+        "loadbalancerpool",
+        "loadbalancerpoolmember",
+        "healthcheckmonitor",
+        "certificateprofile",
+    ]

nautobot/load_balancers/choices.py

@@ -0,0 +1,167 @@
+"""Custom choices for the Load Balancer models."""
+
+from nautobot.core.choices import ChoiceSet
+
+
+class SourceNATTypeChoices(ChoiceSet):
+    """Source NAT Type choices for VirtualServers."""
+
+    TYPE_AUTO = "auto"
+    TYPE_POOL = "pool"
+    TYPE_STATIC = "static"
+
+    CHOICES = (
+        (TYPE_AUTO, "Auto"),
+        (TYPE_POOL, "Pool"),
+        (TYPE_STATIC, "Static"),
+    )
+
+
+class LoadBalancerTypeChoices(ChoiceSet):
+    """Load balancer type choices for VirtualServers."""
+
+    TYPE_LAYER2 = "layer2"
+    TYPE_LAYER4 = "layer4"
+    TYPE_LAYER7 = "layer7"
+    TYPE_DNS = "dns"
+
+    CHOICES = (
+        (TYPE_LAYER2, "Layer 2"),
+        (TYPE_LAYER4, "Layer 4"),
+        (TYPE_LAYER7, "Layer 7"),
+        (TYPE_DNS, "DNS"),
+    )
+
+
+class ProtocolChoices(ChoiceSet):
+    """Protocol choices for VirtualServers."""
+
+    # Layer4
+    PROTOCOL_TCP = "tcp"
+    PROTOCOL_UDP = "udp"
+    PROTOCOL_ICMP = "icmp"
+    PROTOCOL_SCTP = "sctp"
+
+    # Layer7
+    PROTOCOL_HTTP = "http"
+    PROTOCOL_HTTPS = "https"
+    PROTOCOL_HTTP2 = "http2"
+    PROTOCOL_GRPC = "grpc"
+    PROTOCOL_QUIC = "quic"
+
+    # DNS
+    PROTOCOL_DNS = "dns"
+
+    # Any
+    PROTOCOL_ANY = "any"
+
+    CHOICES = (
+        (
+            "Layer 4",
+            (
+                (PROTOCOL_TCP, "TCP"),
+                (PROTOCOL_UDP, "UDP"),
+                (PROTOCOL_ICMP, "ICMP"),
+                (PROTOCOL_SCTP, "SCTP"),
+            ),
+        ),
+        (
+            "Layer 7",
+            (
+                (PROTOCOL_HTTP, "HTTP"),
+                (PROTOCOL_HTTPS, "HTTPS"),
+                (PROTOCOL_HTTP2, "HTTP2"),
+                (PROTOCOL_GRPC, "gRPC"),
+                (PROTOCOL_QUIC, "QUIC"),
+            ),
+        ),
+        ("DNS", ((PROTOCOL_DNS, "DNS"),)),
+        ("Any", ((PROTOCOL_ANY, "Any"),)),
+    )
+
+
+class LoadBalancingAlgorithmChoices(ChoiceSet):
+    """Choices for the load_balancing_algorithm field on the LoadBalancerPool model."""
+
+    # TODO Pull from Netutils
+    ROUND_ROBIN = "round_robin"
+    URL_HASH = "url_hash"
+    LEAST_CONNECTIONS = "least_connections"
+    LEAST_RESPONSE_TIME = "least_response_time"
+    LEAST_BANDWIDTH = "least_bandwidth"
+    LEAST_PACKETS = "least_packets"
+    DOMAIN_HASH = "domain_hash"
+    DESTINATION_IP_HASH = "destination_ip_hash"
+    SOURCE_IP_HASH = "source_ip_hash"
+    SRCIP_DESTIP_HASH = "srcip_destip_hash"
+    LEAST_REQUEST = "least_request"
+    CUSTOM_LOAD = "custom_load"
+    SRCIP_SRCPORT_HASH = "srcip_srcport_hash"
+
+    CHOICES = (
+        (ROUND_ROBIN, "Round Robin"),
+        (URL_HASH, "URL Hash"),
+        (LEAST_CONNECTIONS, "Least Connections"),
+        (LEAST_RESPONSE_TIME, "Least Response Time"),
+        (LEAST_BANDWIDTH, "Least Bandwidth"),
+        (LEAST_PACKETS, "Least Packets"),
+        (DOMAIN_HASH, "Domain Hash"),
+        (DESTINATION_IP_HASH, "Destination IP Hash"),
+        (SOURCE_IP_HASH, "Source IP Hash"),
+        (SRCIP_DESTIP_HASH, "Source IP Destination IP Hash"),
+        (LEAST_REQUEST, "Least Request"),
+        (CUSTOM_LOAD, "Custom Load"),
+        (SRCIP_SRCPORT_HASH, "Source IP Source Port Hash"),
+    )
+
+
+class LoadBalancerPoolMemberStatusChoices(ChoiceSet):
+    """Choices for the status field on the LoadBalancerPoolMember model."""
+
+    STATUS_ACTIVE = "active"
+    STATUS_MAINTENANCE = "maintenance"
+    STATUS_PLANNED = "planned"
+    STATUS_FAILED = "failed"
+    STATUS_DECOMMISSIONING = "decommissioning"
+
+    CHOICES = (
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_MAINTENANCE, "Maintenance"),
+        (STATUS_PLANNED, "Planned"),
+        (STATUS_FAILED, "Failed"),
+        (STATUS_DECOMMISSIONING, "Decommissioning"),
+    )
+
+
+class HealthCheckTypeChoices(ChoiceSet):
+    """Choices for the health_check_type field on the HealthCheckMonitor model."""
+
+    PING = "ping"
+    TCP = "tcp"
+    DNS = "dns"
+    HTTP = "http"
+    HTTPS = "https"
+    CUSTOM = "custom"
+
+    CHOICES = (
+        (PING, "Ping"),
+        (TCP, "TCP"),
+        (DNS, "DNS"),
+        (HTTP, "HTTP"),
+        (HTTPS, "HTTPS"),
+        (CUSTOM, "Custom"),
+    )
+
+
+class CertificateTypeChoices(ChoiceSet):
+    """Choices for the certificate_type field on the CertificateProfile model."""
+
+    TYPE_CLIENT = "client"
+    TYPE_SERVER = "server"
+    TYPE_MTLS = "mutual_tls"
+
+    CHOICES = (
+        (TYPE_CLIENT, "Client"),
+        (TYPE_SERVER, "Server"),
+        (TYPE_MTLS, "mTLS (Mutual TLS)"),
+    )

nautobot/load_balancers/filters.py

@@ -0,0 +1,225 @@
+"""Filtering for nautobot_load_balancer_models."""
+
+import django_filters
+
+from nautobot.cloud.models import CloudService
+from nautobot.core.filters import (
+    BaseFilterSet,
+    MultiValueDateTimeFilter,
+    NameSearchFilterSet,
+    NaturalKeyOrPKMultipleChoiceFilter,
+    SearchFilter,
+)
+from nautobot.dcim.models import Device, DeviceRedundancyGroup, VirtualChassis
+from nautobot.extras.filters import NautobotFilterSet, StatusModelFilterSetMixin
+from nautobot.ipam.models import IPAddress, Prefix
+from nautobot.load_balancers import models
+from nautobot.tenancy.filter_mixins import TenancyModelFilterSetMixin
+
+
+class VirtualServerFilterSet(NameSearchFilterSet, TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VirtualServer."""
+
+    vip = django_filters.ModelMultipleChoiceFilter(
+        queryset=IPAddress.objects.all(),
+        label="VIP (ID)",
+    )
+    source_nat_pool = django_filters.ModelMultipleChoiceFilter(
+        queryset=Prefix.objects.all(),
+        label="Source NAT Pool (ID)",
+    )
+    load_balancer_pool = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.LoadBalancerPool.objects.all(),
+        label="Load Balancer Pool (name or ID)",
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        label="Device (name or ID)",
+    )
+    device_redundancy_group = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=DeviceRedundancyGroup.objects.all(),
+        label="Device Redundancy Group (name or ID)",
+    )
+    cloud_service = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=CloudService.objects.all(),
+        label="Cloud Service (name or ID)",
+    )
+    virtual_chassis = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualChassis.objects.all(),
+        label="Virtual Chassis (name or ID)",
+    )
+    health_check_monitor = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.HealthCheckMonitor.objects.all(),
+        label="Health Check Monitor (name or ID)",
+    )
+    certificate_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.CertificateProfile.objects.all(),
+        label="Certificate Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VirtualServer
+
+        fields = "__all__"
+
+
+class LoadBalancerPoolFilterSet(NameSearchFilterSet, NautobotFilterSet, TenancyModelFilterSetMixin):  # pylint: disable=too-many-ancestors
+    """Filter for LoadBalancerPool."""
+
+    health_check_monitor = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.HealthCheckMonitor.objects.all(),
+        label="Health Check Monitor (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.LoadBalancerPool
+
+        fields = "__all__"
+
+
+class LoadBalancerPoolMemberFilterSet(StatusModelFilterSetMixin, TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for LoadBalancerPoolMember."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "ip_address__host": "icontains",
+            "label": "icontains",
+            "load_balancer_pool__name": "icontains",
+            "port": "icontains",
+        }
+    )
+    ip_address = django_filters.ModelMultipleChoiceFilter(
+        queryset=IPAddress.objects.all(),
+        label="IP Address (ID)",
+    )
+    load_balancer_pool = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.LoadBalancerPool.objects.all(),
+        label="Load Balancer Pool (name or ID)",
+    )
+    health_check_monitor = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.HealthCheckMonitor.objects.all(),
+        label="Health Check Monitor (name or ID)",
+    )
+    certificate_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.CertificateProfile.objects.all(),
+        label="Certificate Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.LoadBalancerPoolMember
+        fields = "__all__"
+
+
+class HealthCheckMonitorFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for HealthCheckMonitor."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "interval": {
+                "lookup_expr": "exact",
+                "preprocessor": int,
+            },
+            "retry": {
+                "lookup_expr": "exact",
+                "preprocessor": int,
+            },
+            "timeout": {
+                "lookup_expr": "exact",
+                "preprocessor": int,
+            },
+            "port": {
+                "lookup_expr": "exact",
+                "preprocessor": int,
+            },
+            "health_check_type": "icontains",
+        }
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.HealthCheckMonitor
+        fields = "__all__"
+
+
+class CertificateProfileFilterSet(TenancyModelFilterSetMixin, NautobotFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for CertificateProfile."""
+
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "certificate_type": "icontains",
+            "cipher": "icontains",
+            "certificate_file_path": "icontains",
+            "chain_file_path": "icontains",
+            "key_file_path": "icontains",
+        }
+    )
+    expiration_date = MultiValueDateTimeFilter()
+    load_balancer_pool_members = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="ip_address__host",
+        queryset=models.LoadBalancerPoolMember.objects.all(),
+        label="Load Balancer Pool Members (ID or host string)",
+    )
+    virtual_servers = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.VirtualServer.objects.all(),
+        label="Virtual Servers",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.CertificateProfile
+        fields = "__all__"
+
+
+class VirtualServerCertificateProfileAssignmentFilterSet(BaseFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for VirtualServerCertificateProfileAssignment."""
+
+    virtual_server = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.VirtualServer.objects.all(),
+        label="Virtual Server (name or ID)",
+    )
+    certificate_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.CertificateProfile.objects.all(),
+        label="Certificate Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.VirtualServerCertificateProfileAssignment
+        fields = "__all__"
+
+
+class LoadBalancerPoolMemberCertificateProfileAssignmentFilterSet(BaseFilterSet):  # pylint: disable=too-many-ancestors
+    """Filter for LoadBalancerPoolMemberCertificateProfileAssignment."""
+
+    load_balancer_pool_member = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.LoadBalancerPoolMember.objects.all(),
+        label="Load Balancer Pool Member (name or ID)",
+    )
+    certificate_profile = NaturalKeyOrPKMultipleChoiceFilter(
+        to_field_name="name",
+        queryset=models.CertificateProfile.objects.all(),
+        label="Certificate Profile (name or ID)",
+    )
+
+    class Meta:
+        """Meta attributes for filter."""
+
+        model = models.LoadBalancerPoolMemberCertificateProfileAssignment
+        fields = "__all__"