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

nautobot/dcim/api/views.py

@@ -16,6 +16,7 @@ from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet, ViewSet
 
 from nautobot.circuits.models import Circuit
+from nautobot.cloud.models import CloudAccount
 from nautobot.core.api.exceptions import ServiceUnavailable
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.api.views import ModelViewSet
@@ -47,6 +48,10 @@ from nautobot.dcim.models import (
     Location,
     LocationType,
     Manufacturer,
+    Module,
+    ModuleBay,
+    ModuleBayTemplate,
+    ModuleType,
     Platform,
     PowerFeed,
     PowerOutlet,
@@ -258,6 +263,7 @@ class RackReservationViewSet(NautobotModelViewSet):
 
 class ManufacturerViewSet(NautobotModelViewSet):
     queryset = Manufacturer.objects.annotate(
+        cloud_account_count=count_related(CloudAccount, "provider"),
         device_type_count=count_related(DeviceType, "manufacturer"),
         inventory_item_count=count_related(InventoryItem, "manufacturer"),
         platform_count=count_related(Platform, "manufacturer"),
@@ -300,43 +306,45 @@ class DeviceTypeViewSet(NautobotModelViewSet):
 
 
 class ConsolePortTemplateViewSet(NautobotModelViewSet):
-    queryset = ConsolePortTemplate.objects.select_related("device_type__manufacturer")
+    queryset = ConsolePortTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.ConsolePortTemplateSerializer
     filterset_class = filters.ConsolePortTemplateFilterSet
 
 
 class ConsoleServerPortTemplateViewSet(NautobotModelViewSet):
-    queryset = ConsoleServerPortTemplate.objects.select_related("device_type__manufacturer")
+    queryset = ConsoleServerPortTemplate.objects.select_related(
+        "device_type__manufacturer", "module_type__manufacturer"
+    )
     serializer_class = serializers.ConsoleServerPortTemplateSerializer
     filterset_class = filters.ConsoleServerPortTemplateFilterSet
 
 
 class PowerPortTemplateViewSet(NautobotModelViewSet):
-    queryset = PowerPortTemplate.objects.select_related("device_type__manufacturer")
+    queryset = PowerPortTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.PowerPortTemplateSerializer
     filterset_class = filters.PowerPortTemplateFilterSet
 
 
 class PowerOutletTemplateViewSet(NautobotModelViewSet):
-    queryset = PowerOutletTemplate.objects.select_related("device_type__manufacturer")
+    queryset = PowerOutletTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.PowerOutletTemplateSerializer
     filterset_class = filters.PowerOutletTemplateFilterSet
 
 
 class InterfaceTemplateViewSet(NautobotModelViewSet):
-    queryset = InterfaceTemplate.objects.select_related("device_type__manufacturer")
+    queryset = InterfaceTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.InterfaceTemplateSerializer
     filterset_class = filters.InterfaceTemplateFilterSet
 
 
 class FrontPortTemplateViewSet(NautobotModelViewSet):
-    queryset = FrontPortTemplate.objects.select_related("device_type__manufacturer")
+    queryset = FrontPortTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.FrontPortTemplateSerializer
     filterset_class = filters.FrontPortTemplateFilterSet
 
 
 class RearPortTemplateViewSet(NautobotModelViewSet):
-    queryset = RearPortTemplate.objects.select_related("device_type__manufacturer")
+    queryset = RearPortTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
     serializer_class = serializers.RearPortTemplateSerializer
     filterset_class = filters.RearPortTemplateFilterSet
 
@@ -347,6 +355,12 @@ class DeviceBayTemplateViewSet(NautobotModelViewSet):
     filterset_class = filters.DeviceBayTemplateFilterSet
 
 
+class ModuleBayTemplateViewSet(NautobotModelViewSet):
+    queryset = ModuleBayTemplate.objects.select_related("device_type__manufacturer", "module_type__manufacturer")
+    serializer_class = serializers.ModuleBayTemplateSerializer
+    filterset_class = filters.ModuleBayTemplateFilterSet
+
+
 #
 # Platforms
 #
@@ -619,6 +633,14 @@ class InventoryItemViewSet(NautobotModelViewSet):
     filterset_class = filters.InventoryItemFilterSet
 
 
+class ModuleBayViewSet(NautobotModelViewSet):
+    queryset = ModuleBay.objects.select_related(
+        "parent_device__tenant", "parent_device__location", "parent_module"
+    ).prefetch_related("installed_module", "tags")
+    serializer_class = serializers.ModuleBaySerializer
+    filterset_class = filters.ModuleBayFilterSet
+
+
 #
 # Connections
 # TODO: remove these in favor of using the ConsolePort/PowerPort/Interface API endpoints and/or Cable endpoint.
@@ -837,3 +859,27 @@ class ControllerManagedDeviceGroupViewSet(NautobotModelViewSet):
 
     serializer_class = serializers.ControllerManagedDeviceGroupSerializer
     filterset_class = filters.ControllerManagedDeviceGroupFilterSet
+
+
+#
+# Modules
+#
+
+
+class ModuleViewSet(NautobotModelViewSet):
+    queryset = Module.objects.select_related(
+        "parent_module_bay__parent_device__location",
+        "parent_module_bay__parent_device__tenant",
+        "module_type__manufacturer",
+        "tenant",
+        "role",
+        "location",
+    ).prefetch_related("module_bays", "tags")
+    serializer_class = serializers.ModuleSerializer
+    filterset_class = filters.ModuleFilterSet
+
+
+class ModuleTypeViewSet(NautobotModelViewSet):
+    queryset = ModuleType.objects.select_related("manufacturer").prefetch_related("tags", "modules")
+    serializer_class = serializers.ModuleTypeSerializer
+    filterset_class = filters.ModuleTypeFilterSet

nautobot/dcim/apps.py

@@ -2,6 +2,7 @@ from nautobot.core.apps import NautobotConfig
 
 
 class DCIMConfig(NautobotConfig):
+    default = True
     name = "nautobot.dcim"
     verbose_name = "DCIM"
     searchable_models = [
@@ -12,6 +13,8 @@ class DCIMConfig(NautobotConfig):
         "deviceredundancygroup",
         "devicetype",
         "location",
+        "module",
+        "moduletype",
         "powerfeed",
         "rack",
         "rackgroup",

nautobot/dcim/choices.py

@@ -1536,3 +1536,28 @@ class SoftwareVersionStatusChoices(ChoiceSet):
         (STATUS_EXTENDED_SUPPORT, "Extended Support"),
         (STATUS_END_OF_LIFE, "End-of-Life"),
     )
+
+
+#
+# Modules
+#
+
+
+class ModuleStatusChoices(ChoiceSet):
+    STATUS_OFFLINE = "offline"
+    STATUS_ACTIVE = "active"
+    STATUS_PLANNED = "planned"
+    STATUS_STAGED = "staged"
+    STATUS_FAILED = "failed"
+    STATUS_INVENTORY = "inventory"
+    STATUS_DECOMMISSIONING = "decommissioning"
+
+    CHOICES = (
+        (STATUS_OFFLINE, "Offline"),
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_PLANNED, "Planned"),
+        (STATUS_STAGED, "Staged"),
+        (STATUS_FAILED, "Failed"),
+        (STATUS_INVENTORY, "Inventory"),
+        (STATUS_DECOMMISSIONING, "Decommissioning"),
+    )

nautobot/dcim/constants.py

@@ -118,3 +118,10 @@ NETUTILS_NETWORK_DRIVER_MAPPING_NAMES = {
     "pyntc",
     "scrapli",
 }
+
+#
+# Modules
+#
+
+# Limit of 4 allows recursion depth of Device->ModuleBay->Module->ModuleBay->Module->ModuleBay->Module->ModuleBay->Module
+MODULE_RECURSION_DEPTH_LIMIT = 4

nautobot/dcim/factory.py

@@ -5,10 +5,11 @@ from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
 import factory
 from faker import Faker
-import pytz
+from timezone_field import TimeZoneFormField
 
 from nautobot.circuits.models import CircuitTermination
 from nautobot.core.factory import (
+    BaseModelFactory,
     get_random_instances,
     NautobotBoolIterator,
     OrganizationalModelFactory,
@@ -17,7 +18,12 @@ from nautobot.core.factory import (
     UniqueFaker,
 )
 from nautobot.dcim.choices import (
+    ConsolePortTypeChoices,
     DeviceRedundancyGroupFailoverStrategyChoices,
+    InterfaceTypeChoices,
+    PortTypeChoices,
+    PowerOutletTypeChoices,
+    PowerPortTypeChoices,
     RackDimensionUnitChoices,
     RackTypeChoices,
     RackWidthChoices,
@@ -25,20 +31,31 @@ from nautobot.dcim.choices import (
     SubdeviceRoleChoices,
 )
 from nautobot.dcim.models import (
+    ConsolePortTemplate,
+    ConsoleServerPortTemplate,
     Controller,
     ControllerManagedDeviceGroup,
     Device,
     DeviceFamily,
     DeviceRedundancyGroup,
     DeviceType,
+    FrontPortTemplate,
+    InterfaceTemplate,
     Location,
     LocationType,
     Manufacturer,
+    Module,
+    ModuleBay,
+    ModuleBayTemplate,
+    ModuleType,
     Platform,
+    PowerOutletTemplate,
     PowerPanel,
+    PowerPortTemplate,
     Rack,
     RackGroup,
     RackReservation,
+    RearPortTemplate,
     SoftwareImageFile,
     SoftwareVersion,
 )
@@ -93,6 +110,8 @@ NETWORK_DRIVERS = {
     "Palo Alto": ["paloalto_panos"],
 }
 
+TIME_ZONES = {timezone for timezone, _ in TimeZoneFormField().choices}
+
 
 # Retrieve correct rack reservation units
 def get_rack_reservation_units(obj):
@@ -122,8 +141,6 @@ class DeviceFactory(PrimaryModelFactory):
             "has_device_redundancy_group",
             "has_platform",
             "has_serial",
-            "has_software_image_files",
-            "has_software_version",
             "has_tenant",
         )
 
@@ -140,7 +157,7 @@ class DeviceFactory(PrimaryModelFactory):
         lambda: Location.objects.filter(location_type__content_types=ContentType.objects.get_for_model(Device)),
         allow_null=False,
     )
-    name = factory.LazyAttributeSequence(lambda o, n: f"{o.device_type.model} Device - {o.location} - {n + 1}")
+    name = factory.LazyAttributeSequence(lambda o, n: f"{o.device_type.model}-{n + 1}")
 
     has_tenant = NautobotBoolIterator()
     tenant = factory.Maybe("has_tenant", random_instance(Tenant))
@@ -172,12 +189,7 @@ class DeviceFactory(PrimaryModelFactory):
     has_comments = NautobotBoolIterator()
     comments = factory.Maybe("has_comments", factory.Faker("bs"))
 
-    has_software_version = NautobotBoolIterator()
-    software_version = factory.Maybe(
-        "has_software_version",
-        factory.LazyAttribute(lambda o: get_random_software_version_for_device_type(o.device_type)),
-        None,
-    )
+    software_version = factory.LazyAttribute(lambda o: get_random_software_version_for_device_type(o.device_type))
 
     @factory.post_generation
     def software_image_files(self, create, extracted, **kwargs):
@@ -243,6 +255,18 @@ class DeviceFactory(PrimaryModelFactory):
     # )
 
 
+device_types = (
+    "Router",
+    "Switch",
+    "Firewall",
+    "Load Balancer",
+    "WLAN Controller",
+    "Access Point",
+    "SAN Fabric",
+    "Console Server",
+)
+
+
 class DeviceTypeFactory(PrimaryModelFactory):
     class Meta:
         model = DeviceType
@@ -250,7 +274,6 @@ class DeviceTypeFactory(PrimaryModelFactory):
             "has_comments",
             "has_device_family",
             "has_part_number",
-            "has_software_image_files",
             "is_subdevice_child",
         )
 
@@ -259,7 +282,21 @@ class DeviceTypeFactory(PrimaryModelFactory):
 
     manufacturer = random_instance(Manufacturer)
 
-    model = factory.LazyAttributeSequence(lambda o, n: f"{o.manufacturer.name} DeviceType {n + 1}")
+    @factory.lazy_attribute
+    def model(self):
+        """
+        Use a random unused-for-this-manufacturer element from `device_types` if any.
+
+        If all are already used, append " 2" to all device-type strings and try again, and so forth.
+        """
+        possible_device_types = set(device_types)
+        count = 2
+        current_models = set(DeviceType.objects.filter(manufacturer=self.manufacturer).values_list("model", flat=True))
+        unused_models = possible_device_types.difference(current_models)
+        while not unused_models:
+            unused_models = {f"{device_type} {count}" for device_type in device_types}.difference(current_models)
+            count += 1
+        return factory.random.randgen.choice(list(unused_models))
 
     has_part_number = NautobotBoolIterator()
     part_number = factory.Maybe("has_part_number", factory.Faker("ean", length=8), "")
@@ -280,16 +317,14 @@ class DeviceTypeFactory(PrimaryModelFactory):
     has_comments = NautobotBoolIterator()
     comments = factory.Maybe("has_comments", factory.Faker("paragraph"), "")
 
-    has_software_image_files = NautobotBoolIterator()
-
     @factory.post_generation
     def software_image_files(self, create, extracted, **kwargs):
-        if not create or not DeviceTypeFactory.has_software_image_files.evaluate(None, None, None):
+        if not create:
             return
         if extracted:
             self.software_image_files.set(extracted)
         else:
-            self.software_image_files.set(get_random_instances(SoftwareImageFile, minimum=1))
+            self.software_image_files.set(get_random_instances(SoftwareImageFile))
 
 
 class DeviceRedundancyGroupFactory(PrimaryModelFactory):
@@ -401,6 +436,7 @@ class LocationTypeFactory(OrganizationalModelFactory):
     def content_types(self, create, extract, **kwargs):
         """Assign some contenttypes to a location after generation"""
         if self.name in ["Root", "Campus", "Building"]:
+            # All appropriate content-types
             self.content_types.set(ContentType.objects.filter(FeatureQuery("locations").get_query()))
         elif self.name in ["Floor"]:
             self.content_types.set(
@@ -438,6 +474,7 @@ class LocationTypeFactory(OrganizationalModelFactory):
                     ContentType.objects.get_for_model(Controller),
                     ContentType.objects.get_for_model(CircuitTermination),
                     ContentType.objects.get_for_model(Device),
+                    ContentType.objects.get_for_model(Module),
                     ContentType.objects.get_for_model(PowerPanel),
                     ContentType.objects.get_for_model(Rack),
                     ContentType.objects.get_for_model(RackGroup),
@@ -478,7 +515,7 @@ class LocationFactory(PrimaryModelFactory):
     facility = factory.Maybe("has_facility", factory.Faker("building_number"), "")
 
     has_time_zone = NautobotBoolIterator()
-    time_zone = factory.Maybe("has_time_zone", factory.Faker("random_element", elements=pytz.common_timezones))
+    time_zone = factory.Maybe("has_time_zone", factory.Faker("random_element", elements=TIME_ZONES))
 
     has_physical_address = NautobotBoolIterator()
     physical_address = factory.Maybe("has_physical_address", factory.Faker("address"))
@@ -641,7 +678,7 @@ class SoftwareImageFileFactory(PrimaryModelFactory):
         allow_null=False,
     )
     software_version = random_instance(SoftwareVersion, allow_null=False)
-    image_file_name = factory.Faker("file_name", extension="bin")
+    image_file_name = UniqueFaker("file_name", extension="bin")
     image_file_checksum = factory.Maybe("has_image_file_checksum", factory.Faker("md5"), "")
     hashing_algorithm = factory.Maybe(
         "has_hashing_algorithm",
@@ -711,3 +748,197 @@ class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
         lambda o: o.parent.controller if o.parent else factory.random.randgen.choice(Controller.objects.all())
     )
     weight = factory.Faker("pyint", min_value=1, max_value=1000)
+
+
+module_types = (
+    "Supervisor",
+    "Line Card",
+    "Fabric",
+)
+
+
+class ModuleTypeFactory(PrimaryModelFactory):
+    class Meta:
+        model = ModuleType
+        exclude = ("has_part_number",)
+
+    manufacturer = random_instance(Manufacturer, allow_null=False)
+
+    has_part_number = NautobotBoolIterator()
+    part_number = factory.Maybe("has_part_number", factory.Faker("ean", length=8), "")
+
+    @factory.lazy_attribute
+    def model(self):
+        """
+        Use a random unused-for-this-manufacturer element from `module_types` if any.
+
+        If all are already used, append " 2" to all module-type strings and try again, and so forth.
+        """
+        possible_module_types = set(module_types)
+        count = 2
+        current_models = set(ModuleType.objects.filter(manufacturer=self.manufacturer).values_list("model", flat=True))
+        unused_models = possible_module_types.difference(current_models)
+        while not unused_models:
+            unused_models = {f"{module_type} {count}" for module_type in module_types}.difference(current_models)
+            count += 1
+        return factory.random.randgen.choice(list(unused_models))
+
+
+class ModuleFactory(PrimaryModelFactory):
+    class Meta:
+        model = Module
+        exclude = (
+            "has_asset_tag",
+            "has_parent_module_bay",
+            "has_role",
+            "has_serial",
+            "has_tenant",
+        )
+
+    module_type = random_instance(ModuleType, allow_null=False)
+    status = random_instance(
+        lambda: Status.objects.get_for_model(Module),
+        allow_null=False,
+    )
+    has_parent_module_bay = NautobotBoolIterator()
+    parent_module_bay = factory.Maybe(
+        "has_parent_module_bay",
+        random_instance(lambda: ModuleBay.objects.filter(installed_module__isnull=True), allow_null=False),
+        None,
+    )
+    location = factory.Maybe(
+        "has_parent_module_bay",
+        None,
+        random_instance(
+            lambda: Location.objects.filter(location_type__content_types=ContentType.objects.get_for_model(Module)),
+            allow_null=False,
+        ),
+    )
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(lambda: Role.objects.get_for_model(Module)),
+        None,
+    )
+    has_asset_tag = NautobotBoolIterator()
+    asset_tag = factory.Maybe("has_asset_tag", UniqueFaker("uuid4"), None)
+    has_serial = NautobotBoolIterator()
+    serial = factory.Maybe("has_serial", factory.Faker("ean", length=8), "")
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe("has_tenant", random_instance(Tenant, allow_null=False), None)
+
+
+class DeviceComponentTemplateFactory(BaseModelFactory):
+    class Params:
+        has_label = NautobotBoolIterator()
+        has_description = NautobotBoolIterator()
+
+    device_type = random_instance(DeviceType.objects.all(), allow_null=False)
+    label = factory.Maybe(
+        "has_label",
+        factory.Faker("word"),
+        "",
+    )
+    description = factory.Maybe(
+        "has_description",
+        factory.Faker("sentence"),
+        "",
+    )
+
+
+class ModularDeviceComponentTemplateFactory(DeviceComponentTemplateFactory):
+    class Params:
+        has_device_type = NautobotBoolIterator()
+
+    device_type = factory.Maybe("has_device_type", random_instance(DeviceType, allow_null=False), None)
+    module_type = factory.Maybe("has_device_type", None, random_instance(ModuleType, allow_null=False))
+
+
+class ConsolePortTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = ConsolePortTemplate
+
+    type = factory.Faker("random_element", elements=ConsolePortTypeChoices.values())
+    name = factory.Sequence(lambda n: f"ConsolePort {n}")
+
+
+class ConsoleServerPortTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = ConsoleServerPortTemplate
+
+    type = factory.Faker("random_element", elements=ConsolePortTypeChoices.values())
+    name = factory.Sequence(lambda n: f"ConsoleServerPort {n}")
+
+
+class PowerPortTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = PowerPortTemplate
+
+    type = factory.Faker("random_element", elements=PowerPortTypeChoices.values())
+    name = factory.Sequence(lambda n: f"PowerPort {n}")
+
+
+class PowerOutletTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = PowerOutletTemplate
+
+    type = factory.Faker("random_element", elements=PowerOutletTypeChoices.values())
+    name = factory.Sequence(lambda n: f"PowerOutlet {n}")
+
+
+class InterfaceTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = InterfaceTemplate
+
+    type = factory.Faker("random_element", elements=InterfaceTypeChoices.values())
+    name = factory.Sequence(lambda n: f"Interface {n}")
+
+
+class FrontPortTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = FrontPortTemplate
+
+    device_type = factory.Maybe(
+        "has_device_type",
+        random_instance(DeviceType.objects.filter(rear_port_templates__isnull=False), allow_null=False),
+        None,
+    )
+    module_type = factory.Maybe(
+        "has_device_type",
+        None,
+        random_instance(ModuleType.objects.filter(rear_port_templates__isnull=False), allow_null=False),
+    )
+    type = factory.Faker("random_element", elements=PortTypeChoices.values())
+    name = factory.Sequence(lambda n: f"FrontPort {n}")
+
+    @factory.lazy_attribute
+    def rear_port_template(self):
+        if self.module_type:
+            return factory.random.randgen.choice(self.module_type.rear_port_templates.all())
+        else:
+            return factory.random.randgen.choice(self.device_type.rear_port_templates.all())
+
+    @factory.lazy_attribute
+    def rear_port_position(self):
+        return self.rear_port_template.front_port_templates.count() + 1
+
+
+class RearPortTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = RearPortTemplate
+
+    type = factory.Faker("random_element", elements=PortTypeChoices.values())
+    name = factory.Sequence(lambda n: f"RearPort {n}")
+    positions = factory.Sequence(lambda n: n + 100)
+
+
+class ModuleBayTemplateFactory(ModularDeviceComponentTemplateFactory):
+    class Meta:
+        model = ModuleBayTemplate
+
+    name = factory.Sequence(lambda n: f"ModuleBay {n}")
+    position = factory.Maybe(
+        "has_device_type",
+        factory.LazyAttribute(lambda o: o.device_type.module_bay_templates.count() + 1),
+        factory.LazyAttribute(lambda o: o.module_type.module_bay_templates.count() + 1),
+    )