nautobot 2.2.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

nautobot/cloud/api/serializers.py

@@ -0,0 +1,54 @@
+from django.contrib.contenttypes.models import ContentType
+
+from nautobot.cloud import models
+from nautobot.core.api import NautobotModelSerializer, ValidatedModelSerializer
+from nautobot.core.api.fields import ContentTypeField
+from nautobot.extras.api.mixins import (
+    TaggedModelSerializerMixin,
+)
+from nautobot.extras.utils import FeatureQuery
+
+#
+# Cloud Account
+#
+
+
+class CloudAccountSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
+    class Meta:
+        model = models.CloudAccount
+        fields = "__all__"
+
+
+class CloudResourceTypeSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
+    content_types = ContentTypeField(
+        queryset=ContentType.objects.filter(FeatureQuery("cloud_resource_types").get_query()),
+        many=True,
+    )
+
+    class Meta:
+        model = models.CloudResourceType
+        fields = "__all__"
+
+
+class CloudNetworkSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
+    class Meta:
+        model = models.CloudNetwork
+        fields = "__all__"
+
+
+class CloudNetworkPrefixAssignmentSerializer(ValidatedModelSerializer):
+    class Meta:
+        model = models.CloudNetworkPrefixAssignment
+        fields = "__all__"
+
+
+class CloudServiceSerializer(TaggedModelSerializerMixin, NautobotModelSerializer):
+    class Meta:
+        model = models.CloudService
+        fields = "__all__"
+
+
+class CloudServiceNetworkAssignmentSerializer(ValidatedModelSerializer):
+    class Meta:
+        model = models.CloudServiceNetworkAssignment
+        fields = "__all__"

nautobot/cloud/api/urls.py

@@ -0,0 +1,16 @@
+from nautobot.core.api.routers import OrderedDefaultRouter
+
+from . import views
+
+router = OrderedDefaultRouter(view_name="Cloud")
+
+# Cloud Accounts
+router.register("cloud-accounts", views.CloudAccountViewSet)
+router.register("cloud-network-prefix-assignments", views.CloudNetworkPrefixAssignmentViewSet)
+router.register("cloud-networks", views.CloudNetworkViewSet)
+router.register("cloud-resource-types", views.CloudResourceTypeViewSet)
+router.register("cloud-service-network-assignments", views.CloudServiceNetworkAssignmentViewSet)
+router.register("cloud-services", views.CloudServiceViewSet)
+
+app_name = "cloud-api"
+urlpatterns = router.urls

nautobot/cloud/api/views.py

@@ -0,0 +1,48 @@
+from nautobot.cloud import filters, models
+from nautobot.extras.api.views import NautobotModelViewSet
+
+from . import serializers
+
+#
+# Cloud Account
+#
+
+
+class CloudAccountViewSet(NautobotModelViewSet):
+    queryset = models.CloudAccount.objects.select_related("provider", "secrets_group")
+    serializer_class = serializers.CloudAccountSerializer
+    filterset_class = filters.CloudAccountFilterSet
+
+
+class CloudResourceTypeViewSet(NautobotModelViewSet):
+    queryset = models.CloudResourceType.objects.select_related("provider")
+    serializer_class = serializers.CloudResourceTypeSerializer
+    filterset_class = filters.CloudResourceTypeFilterSet
+
+
+class CloudNetworkViewSet(NautobotModelViewSet):
+    queryset = models.CloudNetwork.objects.select_related(
+        "cloud_resource_type", "cloud_account", "parent"
+    ).prefetch_related("prefixes")
+    serializer_class = serializers.CloudNetworkSerializer
+    filterset_class = filters.CloudNetworkFilterSet
+
+
+class CloudNetworkPrefixAssignmentViewSet(NautobotModelViewSet):
+    queryset = models.CloudNetworkPrefixAssignment.objects.select_related("cloud_network", "prefix")
+    serializer_class = serializers.CloudNetworkPrefixAssignmentSerializer
+    filterset_class = filters.CloudNetworkPrefixAssignmentFilterSet
+
+
+class CloudServiceViewSet(NautobotModelViewSet):
+    queryset = models.CloudService.objects.select_related("cloud_account", "cloud_resource_type").prefetch_related(
+        "cloud_networks"
+    )
+    serializer_class = serializers.CloudServiceSerializer
+    filterset_class = filters.CloudServiceFilterSet
+
+
+class CloudServiceNetworkAssignmentViewSet(NautobotModelViewSet):
+    queryset = models.CloudServiceNetworkAssignment.objects.select_related("cloud_network", "cloud_service")
+    serializer_class = serializers.CloudServiceNetworkAssignmentSerializer
+    filterset_class = filters.CloudServiceNetworkAssignmentFilterSet

nautobot/cloud/apps.py

@@ -0,0 +1,13 @@
+from nautobot.core.apps import NautobotConfig
+
+
+class CloudConfig(NautobotConfig):
+    default = True
+    name = "nautobot.cloud"
+    verbose_name = "Cloud"
+    searchable_models = [
+        "cloudaccount",
+        "cloudnetwork",
+        "cloudresourcetype",
+        "cloudservice",
+    ]

nautobot/cloud/factory.py

@@ -0,0 +1,113 @@
+from django.contrib.contenttypes.models import ContentType
+import factory
+
+from nautobot.cloud import models
+from nautobot.core.factory import (
+    get_random_instances,
+    NautobotBoolIterator,
+    PrimaryModelFactory,
+    random_instance,
+    UniqueFaker,
+)
+from nautobot.dcim.models import Manufacturer
+from nautobot.extras.utils import FeatureQuery
+from nautobot.ipam.models import Prefix
+
+
+class CloudAccountFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.CloudAccount
+        exclude = ("has_description",)
+
+    name = UniqueFaker("company")
+    account_number = factory.Faker("pyint", min_value=4200000000, max_value=4294967294)
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    provider = random_instance(Manufacturer, allow_null=False)
+    # TODO: once SecretsGroupFactory is implemented:
+    # has_secrets_group = NautobotBoolIterator()
+    # secrets_group = factory.Maybe(
+    #     "has_secrets_group",
+    #     random_instance(SecretsGroup),
+    # )
+
+
+class CloudResourceTypeFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.CloudResourceType
+        exclude = ("has_description",)
+
+    provider = random_instance(Manufacturer)
+    name = factory.LazyAttributeSequence(lambda o, n: f"{o.provider.name} CloudResourceType {n + 1}")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    # TODO: if we add a `config_schema` here, then CloudNetworkFactory and CloudServiceFactory have to follow it...
+
+    @factory.post_generation
+    def content_types(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.content_types.set(extracted)
+            else:
+                self.content_types.set(
+                    get_random_instances(
+                        lambda: ContentType.objects.filter(FeatureQuery("cloud_resource_types").get_query()), minimum=1
+                    )
+                )
+
+
+class CloudNetworkFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.CloudNetwork
+        exclude = ("has_description", "has_parent")
+
+    name = factory.LazyAttributeSequence(lambda o, n: f"CloudNetwork {n + 1}")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    cloud_resource_type = random_instance(
+        lambda: models.CloudResourceType.objects.get_for_model(models.CloudNetwork), allow_null=False
+    )
+    cloud_account = random_instance(models.CloudAccount, allow_null=False)
+    has_parent = NautobotBoolIterator()
+    extra_config = factory.Faker("pydict", value_types=[str, bool, int])
+
+    @factory.lazy_attribute
+    def parent(self):
+        if not self.has_parent:
+            return None
+        candidate_parents = models.CloudNetwork.objects.filter(parent__isnull=True).exclude(pk=self.id)
+        if candidate_parents.exists():
+            return factory.random.randgen.choice(candidate_parents)
+        return None
+
+    @factory.post_generation
+    def prefixes(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.prefixes.set(extracted)
+            else:
+                self.prefixes.set(get_random_instances(Prefix))
+
+
+class CloudServiceFactory(PrimaryModelFactory):
+    class Meta:
+        model = models.CloudService
+        exclude = ("has_cloudaccount", "has_description")
+
+    name = factory.LazyAttributeSequence(lambda o, n: f"CloudService {n + 1}")
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+    has_cloudaccount = NautobotBoolIterator()
+    cloud_account = factory.Maybe("has_cloudaccount", random_instance(models.CloudAccount, allow_null=False), None)
+    cloud_resource_type = random_instance(
+        lambda: models.CloudResourceType.objects.get_for_model(models.CloudService), allow_null=False
+    )
+    extra_config = factory.Faker("pydict", value_types=[str, bool, int])
+
+    @factory.post_generation
+    def cloud_networks(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.cloud_networks.set(extracted)
+            else:
+                self.cloud_networks.set(get_random_instances(models.CloudNetwork))

nautobot/cloud/filters.py

@@ -0,0 +1,187 @@
+import django_filters
+
+from nautobot.cloud import models
+from nautobot.core.filters import (
+    BaseFilterSet,
+    ContentTypeMultipleChoiceFilter,
+    NaturalKeyOrPKMultipleChoiceFilter,
+    SearchFilter,
+)
+from nautobot.dcim.models import Manufacturer
+from nautobot.extras.filters import NautobotFilterSet
+from nautobot.extras.models import SecretsGroup
+from nautobot.extras.utils import FeatureQuery
+from nautobot.ipam.models import Prefix
+
+
+class CloudAccountFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "account_number": "icontains",
+            "provider__name": "icontains",
+        },
+    )
+    provider = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="provider",
+        queryset=Manufacturer.objects.all(),
+        to_field_name="name",
+        label="Provider (name or ID)",
+    )
+    secrets_group = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=SecretsGroup.objects.all(),
+        to_field_name="name",
+        label="Secrets group (name or ID)",
+    )
+
+    class Meta:
+        model = models.CloudAccount
+        fields = [
+            "account_number",
+            "description",
+            "id",
+            "name",
+            "provider",
+            "secrets_group",
+            "tags",
+        ]
+
+
+class CloudResourceTypeFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "provider__name": "icontains",
+        },
+    )
+    provider = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="provider",
+        queryset=Manufacturer.objects.all(),
+        to_field_name="name",
+        label="Provider (name or ID)",
+    )
+    content_types = ContentTypeMultipleChoiceFilter(choices=FeatureQuery("cloud_resource_types").get_choices)
+
+    class Meta:
+        model = models.CloudResourceType
+        fields = ["id", "name", "description", "tags"]
+
+
+class CloudNetworkFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "parent__name": "icontains",
+            "parent__description": "icontains",
+            "cloud_account__name": "icontains",
+            "cloud_account__description": "icontains",
+            "cloud_resource_type__name": "icontains",
+            "cloud_resource_type__description": "icontains",
+        },
+    )
+    cloud_resource_type = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudResourceType.objects.all(),
+        label="Cloud resource type (name or ID)",
+    )
+    cloud_account = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudAccount.objects.all(),
+        label="Cloud account (name or ID)",
+    )
+    cloud_services = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudService.objects.all(),
+        label="Cloud services (name or ID)",
+    )
+    parent = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudNetwork.objects.all(),
+        label="Parent cloud network (name or ID)",
+    )
+    prefixes = django_filters.ModelMultipleChoiceFilter(queryset=Prefix.objects.all())
+
+    class Meta:
+        model = models.CloudNetwork
+        fields = ["id", "name", "description", "tags"]
+
+
+class CloudNetworkPrefixAssignmentFilterSet(BaseFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "cloud_network__name": "icontains",
+            "cloud_network__description": "icontains",
+            # TODO: add prefix search, currently implemented as a custom search() method on PrefixFilterSet
+        }
+    )
+    cloud_network = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudNetwork.objects.all(),
+        label="Cloud network (name or ID)",
+    )
+    # Prefix doesn't have an appropriate natural key for NaturalKeyOrPKMultipleChoiceFilter
+    prefix = django_filters.ModelMultipleChoiceFilter(queryset=Prefix.objects.all())
+
+    class Meta:
+        model = models.CloudNetworkPrefixAssignment
+        fields = ["id"]
+
+
+class CloudServiceFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "name": "icontains",
+            "description": "icontains",
+            "cloud_account__name": "icontains",
+            "cloud_account__description": "icontains",
+            "cloud_networks__name": "icontains",
+            "cloud_networks__description": "icontains",
+            "cloud_resource_type__name": "icontains",
+            "cloud_resource_type__description": "icontains",
+        }
+    )
+    cloud_account = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudAccount.objects.all(),
+        label="Cloud account (name or ID)",
+    )
+    cloud_networks = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudNetwork.objects.all(),
+        label="Cloud networks (name or ID)",
+    )
+    cloud_resource_type = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudResourceType.objects.all(),
+        label="Cloud resource type (name or ID)",
+    )
+
+    class Meta:
+        model = models.CloudService
+        fields = ["id", "name", "description", "cloud_account", "cloud_networks", "cloud_resource_type", "tags"]
+
+
+class CloudServiceNetworkAssignmentFilterSet(BaseFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "cloud_network__name": "icontains",
+            "cloud_network__description": "icontains",
+            "cloud_network__cloud_account__name": "icontains",
+            "cloud_network__cloud_account__description": "icontains",
+            "cloud_network__cloud_resource_type__name": "icontains",
+            "cloud_network__cloud_resource_type__description": "icontains",
+            "cloud_service__name": "icontains",
+            "cloud_service__description": "icontains",
+            "cloud_service__cloud_account__name": "icontains",
+            "cloud_service__cloud_account__description": "icontains",
+            "cloud_service__cloud_resource_type__name": "icontains",
+            "cloud_service__cloud_resource_type__description": "icontains",
+        }
+    )
+    cloud_network = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudNetwork.objects.all(),
+        label="Cloud network (name or ID)",
+    )
+    cloud_service = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=models.CloudService.objects.all(),
+        label="Cloud service (name or ID)",
+    )
+
+    class Meta:
+        model = models.CloudServiceNetworkAssignment
+        fields = ["id"]