nautobot 2.3.1__py3-none-any.whl → 2.3.3__py3-none-any.whl

nautobot/extras/tests/test_models.py

@@ -14,8 +14,15 @@ from django.db.models import ProtectedError
 from django.db.utils import IntegrityError
 from django.test import override_settings
 from django.test.utils import isolate_apps
-from django.utils.timezone import now
+from django.utils.timezone import get_default_timezone, now
+from django_celery_beat.tzcrontab import TzAwareCrontab
 from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
+import time_machine
+
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:  # python 3.8
+    from backports.zoneinfo import ZoneInfo
 
 from nautobot.circuits.models import CircuitType
 from nautobot.core.choices import ColorChoices
@@ -30,6 +37,7 @@ from nautobot.dcim.models import (
     Platform,
 )
 from nautobot.extras.choices import (
+    JobExecutionType,
     JobResultStatusChoices,
     LogLevelChoices,
     MetadataTypeDataTypeChoices,
@@ -65,6 +73,7 @@ from nautobot.extras.models import (
     ObjectMetadata,
     Role,
     SavedView,
+    ScheduledJob,
     Secret,
     SecretsGroup,
     SecretsGroupAssociation,
@@ -1082,12 +1091,15 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
     def test_job_class(self):
+        self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.job_class.description, "Validate job import")
 
+        self.assertIsNotNone(self.app_job.job_class)
         self.assertEqual(self.app_job.job_class, ExampleJob)
 
     def test_class_path(self):
         self.assertEqual(self.local_job.class_path, "pass.TestPass")
+        self.assertIsNotNone(self.local_job.job_class)
         self.assertEqual(self.local_job.class_path, self.local_job.job_class.class_path)
 
         self.assertEqual(self.app_job.class_path, "example_app.jobs.ExampleJob")
@@ -1109,6 +1121,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
                         self.assertTrue(job_model.enabled)
                     else:
                         self.assertFalse(job_model.enabled)
+                    self.assertIsNotNone(job_model.job_class)
                     for field_name in JOB_OVERRIDABLE_FIELDS:
                         if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
                             pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
@@ -1164,6 +1177,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
             setattr(self.job_containing_sensitive_variables, f"{field_name}_override", False)
         self.job_containing_sensitive_variables.validated_save()
         self.job_containing_sensitive_variables.refresh_from_db()
+        self.assertIsNotNone(self.job_containing_sensitive_variables.job_class)
         for field_name in overridden_attrs:
             self.assertEqual(
                 getattr(self.job_containing_sensitive_variables, field_name),
@@ -1790,6 +1804,295 @@ class SavedViewTest(ModelTestCases.BaseModelTestCase):
         self.assertEqual(self.ipaddress_global_sv.is_shared, True)
 
 
+@override_settings(TIME_ZONE="UTC")
+class ScheduledJobTest(ModelTestCases.BaseModelTestCase):
+    """Tests for the `ScheduledJob` model class."""
+
+    model = ScheduledJob
+
+    def setUp(self):
+        self.user = User.objects.create_user(username="scheduledjobuser")
+        self.job_model = JobModel.objects.get(name="TestPass")
+
+        self.daily_utc_job = ScheduledJob.objects.create(
+            name="Daily UTC Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            interval=JobExecutionType.TYPE_DAILY,
+            start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=get_default_timezone()),
+            time_zone=get_default_timezone(),
+        )
+        self.daily_est_job = ScheduledJob.objects.create(
+            name="Daily EST Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            interval=JobExecutionType.TYPE_DAILY,
+            start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            time_zone=ZoneInfo("America/New_York"),
+        )
+        self.crontab_utc_job = ScheduledJob.create_schedule(
+            job_model=self.job_model,
+            user=self.user,
+            name="Crontab UTC Job",
+            interval=JobExecutionType.TYPE_CUSTOM,
+            crontab="0 17 * * *",
+        )
+        self.crontab_est_job = ScheduledJob.objects.create(
+            name="Crontab EST Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            interval=JobExecutionType.TYPE_CUSTOM,
+            start_time=datetime(year=2050, month=1, day=22, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            time_zone=ZoneInfo("America/New_York"),
+            crontab="0 17 * * *",
+        )
+        self.one_off_utc_job = ScheduledJob.objects.create(
+            name="One-off UTC Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            interval=JobExecutionType.TYPE_FUTURE,
+            start_time=datetime(year=2050, month=1, day=22, hour=0, minute=0, tzinfo=ZoneInfo("UTC")),
+            time_zone=ZoneInfo("UTC"),
+        )
+        self.one_off_est_job = ScheduledJob.create_schedule(
+            job_model=self.job_model,
+            user=self.user,
+            name="One-off EST Job",
+            interval=JobExecutionType.TYPE_FUTURE,
+            start_time=datetime(year=2050, month=1, day=22, hour=0, minute=0, tzinfo=ZoneInfo("America/New_York")),
+        )
+
+    def test_schedule(self):
+        """Test the schedule property."""
+        with self.subTest("Test TYPE_DAILY schedules"):
+            daily_utc_schedule = self.daily_utc_job.schedule
+            daily_est_schedule = self.daily_est_job.schedule
+            self.assertIsInstance(daily_utc_schedule, TzAwareCrontab)
+            self.assertIsInstance(daily_est_schedule, TzAwareCrontab)
+            self.assertNotEqual(daily_utc_schedule, daily_est_schedule)
+            # Crontabs are validated in test_to_cron()
+
+        with self.subTest("Test TYPE_CUSTOM schedules"):
+            crontab_utc_schedule = self.crontab_utc_job.schedule
+            crontab_est_schedule = self.crontab_est_job.schedule
+            self.assertIsInstance(crontab_utc_schedule, TzAwareCrontab)
+            self.assertIsInstance(crontab_est_schedule, TzAwareCrontab)
+            self.assertNotEqual(crontab_utc_schedule, crontab_est_schedule)
+            # Crontabs are validated in test_to_cron()
+
+        with self.subTest("Test TYPE_FUTURE schedules"):
+            # TYPE_FUTURE schedules are one off, not cron tabs:
+            self.assertEqual(self.one_off_utc_job.schedule.clocked_time, self.one_off_utc_job.start_time)
+            self.assertEqual(self.one_off_est_job.schedule.clocked_time, self.one_off_est_job.start_time)
+            self.assertEqual(
+                self.one_off_est_job.schedule.clocked_time - self.one_off_utc_job.schedule.clocked_time,
+                timedelta(hours=5),
+            )
+
+    def test_to_cron(self):
+        """Test the to_cron() method and its interaction with time zone variants."""
+
+        with self.subTest("Test TYPE_DAILY schedule with UTC time zone and UTC schedule time zone"):
+            self.daily_utc_job.refresh_from_db()
+            daily_utc_schedule = self.daily_utc_job.to_cron()
+            self.assertEqual(daily_utc_schedule.tz, ZoneInfo("UTC"))
+            self.assertEqual(daily_utc_schedule.hour, {17})
+            self.assertEqual(daily_utc_schedule.minute, {0})
+            last_run = datetime(2050, 1, 21, 17, 0, tzinfo=ZoneInfo("UTC"))
+            with time_machine.travel("2050-01-22 16:59 +0000"):
+                is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                self.assertFalse(is_due)
+            with time_machine.travel("2050-01-22 17:00 +0000"):
+                is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                self.assertTrue(is_due)
+
+        with self.subTest("Test TYPE_DAILY schedule with UTC time zone and EST schedule time zone"):
+            self.daily_est_job.refresh_from_db()
+            daily_est_schedule = self.daily_est_job.to_cron()
+            self.assertEqual(daily_est_schedule.tz, ZoneInfo("America/New_York"))
+            self.assertEqual(daily_est_schedule.hour, {17})
+            self.assertEqual(daily_est_schedule.minute, {0})
+            last_run = datetime(2050, 1, 21, 22, 0, tzinfo=ZoneInfo("UTC"))
+            with time_machine.travel("2050-01-22 21:59 +0000"):
+                is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                self.assertFalse(is_due)
+            with time_machine.travel("2050-01-22 22:00 +0000"):
+                is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                self.assertTrue(is_due)
+
+        with self.subTest("Test TYPE_CUSTOM schedule with UTC time zone and UTC schedule time zone"):
+            self.crontab_utc_job.refresh_from_db()
+            crontab_utc_schedule = self.crontab_utc_job.to_cron()
+            self.assertEqual(crontab_utc_schedule.tz, ZoneInfo("UTC"))
+            self.assertEqual(crontab_utc_schedule.hour, {17})
+            self.assertEqual(crontab_utc_schedule.minute, {0})
+
+        with self.subTest("Test TYPE_CUSTOM schedule with UTC time zone and EST schedule time zone"):
+            self.crontab_est_job.refresh_from_db()
+            crontab_est_schedule = self.crontab_est_job.to_cron()
+            self.assertEqual(crontab_est_schedule.tz, ZoneInfo("America/New_York"))
+            self.assertEqual(crontab_est_schedule.hour, {17})
+            self.assertEqual(crontab_est_schedule.minute, {0})
+
+        with self.subTest("Test TYPE_FUTURE schedules do not map to cron"):
+            with self.assertRaises(ValueError):
+                self.one_off_utc_job.to_cron()
+            with self.assertRaises(ValueError):
+                self.one_off_est_job.to_cron()
+
+        with override_settings(TIME_ZONE="America/New_York"):
+            with self.subTest("Test TYPE_DAILY schedule with EST time zone and UTC schedule time zone"):
+                self.daily_utc_job.refresh_from_db()
+                daily_utc_schedule = self.daily_utc_job.to_cron()
+                self.assertEqual(daily_utc_schedule.tz, ZoneInfo("UTC"))
+                self.assertEqual(daily_utc_schedule.hour, {17})
+                self.assertEqual(daily_utc_schedule.minute, {0})
+                last_run = datetime(2050, 1, 21, 12, 0, tzinfo=ZoneInfo("America/New_York"))
+                with time_machine.travel("2050-01-22 11:59 -0500"):
+                    is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                    self.assertFalse(is_due)
+                with time_machine.travel("2050-01-22 12:00 -0500"):
+                    is_due, _ = daily_utc_schedule.is_due(last_run_at=last_run)
+                    self.assertTrue(is_due)
+
+            with self.subTest("Test TYPE_DAILY schedule with EST time zone and EST schedule time zone"):
+                self.daily_est_job.refresh_from_db()
+                daily_est_schedule = self.daily_est_job.to_cron()
+                self.assertEqual(daily_est_schedule.tz, ZoneInfo("America/New_York"))
+                self.assertEqual(daily_est_schedule.hour, {17})
+                self.assertEqual(daily_est_schedule.minute, {0})
+                last_run = datetime(2050, 1, 21, 22, 0, tzinfo=ZoneInfo("America/New_York"))
+                with time_machine.travel("2050-01-22 16:59 -0500"):
+                    is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                    self.assertFalse(is_due)
+                with time_machine.travel("2050-01-22 17:00 -0500"):
+                    is_due, _ = daily_est_schedule.is_due(last_run_at=last_run)
+                    self.assertTrue(is_due)
+
+            with self.subTest("Test TYPE_CUSTOM schedule with EST time zone and UTC schedule time zone"):
+                self.crontab_utc_job.refresh_from_db()
+                crontab_utc_schedule = self.crontab_utc_job.to_cron()
+                self.assertEqual(crontab_utc_schedule.tz, ZoneInfo("UTC"))
+                self.assertEqual(crontab_utc_schedule.hour, {17})
+                self.assertEqual(crontab_utc_schedule.minute, {0})
+
+            with self.subTest("Test TYPE_CUSTOM schedule with EST time zone and EST schedule time zone"):
+                self.crontab_est_job.refresh_from_db()
+                crontab_est_schedule = self.crontab_est_job.to_cron()
+                self.assertEqual(crontab_est_schedule.tz, ZoneInfo("America/New_York"))
+                self.assertEqual(crontab_est_schedule.hour, {17})
+                self.assertEqual(crontab_est_schedule.minute, {0})
+
+    def test_crontab_dst(self):
+        """Test that TYPE_CUSTOM behavior around DST is as expected."""
+        cronjob = ScheduledJob.objects.create(
+            name="DST Aware Cronjob",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            enabled=False,
+            interval=JobExecutionType.TYPE_CUSTOM,
+            start_time=datetime(year=2024, month=1, day=1, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            crontab="0 17 * * *",  # 5 PM local time
+            time_zone=ZoneInfo("America/New_York"),
+        )
+
+        # Before DST takes effect
+        with self.subTest("Test UTC time zone with EST job"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-09 21:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 22:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EST time zone with EST job"), override_settings(TIME_ZONE="America/New_York"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-09 16:59 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 17:00 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        # Day that DST takes effect
+        with self.subTest("Test UTC time zone with EDT job"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-10 20:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 21:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EDT time zone with EDT job"), override_settings(TIME_ZONE="America/New_York"):
+            cronjob.refresh_from_db()
+            crontab = cronjob.to_cron()
+            with time_machine.travel("2024-03-10 16:59 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 17:00 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+    def test_daily_dst(self):
+        """Test the interaction of TYPE_DAILY around DST."""
+        daily = ScheduledJob.objects.create(
+            name="Daily Job",
+            task="pass.TestPass",
+            job_model=self.job_model,
+            enabled=False,
+            interval=JobExecutionType.TYPE_DAILY,
+            start_time=datetime(year=2024, month=1, day=1, hour=17, minute=0, tzinfo=ZoneInfo("America/New_York")),
+            time_zone=ZoneInfo("America/New_York"),
+        )
+
+        # Before DST takes effect
+        with self.subTest("Test UTC time zone with EST job"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-09 21:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 22:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EST time zone with EST job"), override_settings(TIME_ZONE="America/New_York"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-09 16:59 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-09 17:00 -0500"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 8, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        # Day that DST takes effect
+        with self.subTest("Test UTC time zone with EDT job"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-10 20:59 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 21:00 +0000"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+        with self.subTest("Test EDT time zone with EDT job"), override_settings(TIME_ZONE="America/New_York"):
+            daily.refresh_from_db()
+            crontab = daily.to_cron()
+            with time_machine.travel("2024-03-10 16:59 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertFalse(is_due)
+            with time_machine.travel("2024-03-10 17:00 -0400"):
+                is_due, _ = crontab.is_due(last_run_at=datetime(2024, 3, 9, 17, 0, tzinfo=ZoneInfo("America/New_York")))
+                self.assertTrue(is_due)
+
+
 class SecretTest(ModelTestCases.BaseModelTestCase):
     """
     Tests for the `Secret` model class.

nautobot/extras/tests/test_views.py

@@ -1744,16 +1744,17 @@ class ScheduledJobTestCase(
         ScheduledJob.objects.create(
             name="test2",
             task="pass.TestPass",
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_DAILY,
             user=user,
             start_time=timezone.now(),
         )
         ScheduledJob.objects.create(
             name="test3",
             task="pass.TestPass",
-            interval=JobExecutionType.TYPE_IMMEDIATELY,
+            interval=JobExecutionType.TYPE_CUSTOM,
             user=user,
             start_time=timezone.now(),
+            crontab="15 10 * * *",
         )
 
     def test_only_enabled_is_listed(self):
@@ -3007,6 +3008,7 @@ class JobCustomTemplateTestCase(TestCase):
         cls.run_url = reverse("extras:job_run", kwargs={"pk": cls.example_job.pk})
 
     def test_rendering_custom_template(self):
+        self.assertIsNotNone(self.example_job.job_class)
         obj_perm = ObjectPermission(name="Test permission", actions=["view", "run"])
         obj_perm.save()
         obj_perm.users.add(self.user)

nautobot/extras/views.py

@@ -2,6 +2,7 @@ import logging
 from urllib.parse import parse_qs
 
 from celery import chain
+from django.conf import settings
 from django.contrib import messages
 from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.models import ContentType
@@ -23,6 +24,11 @@ from django_tables2 import RequestConfig
 from jsonschema.validators import Draft7Validator
 from rest_framework.decorators import action
 
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:  # python 3.8
+    from backports.zoneinfo import ZoneInfo
+
 from nautobot.core.forms import restrict_form_fields
 from nautobot.core.models.querysets import count_related
 from nautobot.core.models.utils import pretty_print_query
@@ -1916,6 +1922,7 @@ class ScheduledJobView(generic.ObjectView):
         return {
             "labels": labels,
             "job_class_found": (job_class is not None),
+            "default_time_zone": ZoneInfo(settings.TIME_ZONE),
             **super().get_extra_context(request, instance),
         }
 

nautobot/ipam/api/views.py

@@ -202,7 +202,7 @@ class PrefixViewSet(NautobotModelViewSet):
                         if requested_prefix["prefix_length"] >= available_prefix.prefixlen:
                             allocated_prefix = f"{available_prefix.network}/{requested_prefix['prefix_length']}"
                             requested_prefix["prefix"] = allocated_prefix
-                            requested_prefix["namespace"] = prefix.namespace.pk
+                            requested_prefix["namespace"] = prefix.namespace
                             break
                     else:
                         return Response(
@@ -210,6 +210,10 @@ class PrefixViewSet(NautobotModelViewSet):
                             status=status.HTTP_204_NO_CONTENT,
                         )
 
+                    # The serializer usage above has mapped "custom_fields" dict to "_custom_field_data".
+                    # We need to convert it back to "custom_fields" as we're going to deserialize it a second time below
+                    requested_prefix["custom_fields"] = requested_prefix.pop("_custom_field_data", {})
+
                     # Remove the allocated prefix from the list of available prefixes
                     available_prefixes.remove(allocated_prefix)
 
@@ -299,7 +303,10 @@ class PrefixViewSet(NautobotModelViewSet):
                 prefix_length = prefix.prefix.prefixlen
                 for requested_ip in requested_ips:
                     requested_ip["address"] = f"{next(available_ips)}/{prefix_length}"
-                    requested_ip["namespace"] = prefix.namespace.pk
+                    requested_ip["namespace"] = prefix.namespace
+                    # The serializer usage above has mapped "custom_fields" dict to "_custom_field_data".
+                    # We need to convert it back to "custom_fields" as we're going to deserialize it a second time below
+                    requested_ip["custom_fields"] = requested_ip.pop("_custom_field_data", {})
 
                 # Initialize the serializer with a list or a single object depending on what was requested
                 context = {"request": request, "depth": 0}

nautobot/ipam/choices.py

@@ -102,6 +102,23 @@ class IPAddressTypeChoices(ChoiceSet):
     )
 
 
+#
+# VRFs
+#
+
+
+class VRFStatusChoices(ChoiceSet):
+    STATUS_ACTIVE = "active"
+    STATUS_DOWN = "down"
+    STATUS_DEPRECATED = "deprecated"
+
+    CHOICES = (
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_DOWN, "Down"),
+        (STATUS_DEPRECATED, "Deprecated"),
+    )
+
+
 #
 # VLANs
 #

nautobot/ipam/factory.py

@@ -84,6 +84,7 @@ class VRFFactory(PrimaryModelFactory):
         model = VRF
         exclude = (
             "has_description",
+            "has_status",
             "has_tenant",
         )
 
@@ -103,6 +104,11 @@ class VRFFactory(PrimaryModelFactory):
     has_description = NautobotBoolIterator()
     description = factory.Maybe("has_description", factory.Faker("text", max_nb_chars=CHARFIELD_MAX_LENGTH), "")
 
+    has_status = NautobotBoolIterator()
+    status = factory.Maybe(
+        "has_status", random_instance(lambda: Status.objects.get_for_model(VRF), allow_null=False), None
+    )
+
     namespace = random_instance(Namespace, allow_null=False)
 
     @factory.post_generation

nautobot/ipam/filters.py

@@ -66,7 +66,7 @@ class NamespaceFilterSet(NautobotFilterSet):
         fields = "__all__"
 
 
-class VRFFilterSet(NautobotFilterSet, TenancyModelFilterSetMixin):
+class VRFFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyModelFilterSetMixin):
     q = SearchFilter(
         filter_predicates={
             "name": "icontains",

nautobot/ipam/forms.py

@@ -125,6 +125,7 @@ class VRFForm(NautobotModelForm, TenancyForm):
             "name",
             "rd",
             "namespace",
+            "status",
             "description",
             "import_targets",
             "export_targets",
@@ -140,10 +141,11 @@ class VRFForm(NautobotModelForm, TenancyForm):
         }
         help_texts = {
             "rd": "Route distinguisher unique to this Namespace (as defined in RFC 4364)",
+            "status": "Operational status of this VRF",
         }
 
 
-class VRFBulkEditForm(TagsBulkEditFormMixin, NautobotBulkEditForm):
+class VRFBulkEditForm(TagsBulkEditFormMixin, StatusModelBulkEditFormMixin, NautobotBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=VRF.objects.all(), widget=forms.MultipleHiddenInput())
     namespace = DynamicModelChoiceField(queryset=Namespace.objects.all(), required=False)
     tenant = DynamicModelChoiceField(queryset=Tenant.objects.all(), required=False)
@@ -162,9 +164,9 @@ class VRFBulkEditForm(TagsBulkEditFormMixin, NautobotBulkEditForm):
         ]
 
 
-class VRFFilterForm(NautobotFilterForm, TenancyFilterForm):
+class VRFFilterForm(NautobotFilterForm, StatusModelFilterFormMixin, TenancyFilterForm):
     model = VRF
-    field_order = ["q", "import_targets", "export_targets", "tenant_group", "tenant"]
+    field_order = ["q", "import_targets", "export_targets", "status", "tenant_group", "tenant"]
     q = forms.CharField(required=False, label="Search")
     import_targets = DynamicModelMultipleChoiceField(
         queryset=RouteTarget.objects.all(), to_field_name="name", required=False

nautobot/ipam/migrations/0048_vrf_status.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.15 on 2024-08-26 17:20
+
+from django.db import migrations
+import django.db.models.deletion
+
+import nautobot.extras.models.statuses
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0114_computedfield_grouping"),
+        ("ipam", "0047_alter_ipaddress_role_alter_ipaddress_status_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="vrf",
+            name="status",
+            field=nautobot.extras.models.statuses.StatusField(
+                blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, to="extras.status"
+            ),
+        ),
+    ]

nautobot/ipam/migrations/0049_vrf_data_migration.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.15 on 2024-08-26 18:05
+
+from django.db import migrations
+
+from nautobot.extras.management import clear_status_choices, populate_status_choices
+
+
+def populate_vrf_status_choices(apps, schema_editor):
+    """Create default Status records for the VRF model."""
+    populate_status_choices(apps, schema_editor, models=["ipam.VRF"])
+
+
+def clear_vrf_status_choices(apps, schema_editor):
+    """Remove default Status records for the VRF model."""
+    clear_status_choices(apps, schema_editor, models=["ipam.VRF"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipam", "0048_vrf_status"),
+    ]
+
+    operations = [
+        migrations.RunPython(populate_vrf_status_choices, clear_vrf_status_choices),
+    ]

nautobot/ipam/models.py

@@ -97,6 +97,7 @@ def get_default_namespace_pk():
     "custom_validators",
     "export_templates",
     "graphql",
+    "statuses",
     "webhooks",
 )
 class VRF(PrimaryModel):
@@ -114,6 +115,7 @@ class VRF(PrimaryModel):
         verbose_name="Route distinguisher",
         help_text="Unique route distinguisher (as defined in RFC 4364)",
     )
+    status = StatusField(blank=True, null=True)
     namespace = models.ForeignKey(
         "ipam.Namespace",
         on_delete=models.PROTECT,
@@ -533,6 +535,10 @@ class Prefix(PrimaryModel):
     def __str__(self):
         return str(self.prefix)
 
+    @property
+    def display(self):
+        return f"{self.prefix}: {self.namespace}"
+
     def _deconstruct_prefix(self, prefix):
         if prefix:
             if isinstance(prefix, str):

nautobot/ipam/tables.py

@@ -217,7 +217,7 @@ class NamespaceTable(BaseTable):
 #
 
 
-class VRFTable(BaseTable):
+class VRFTable(StatusTableMixin, BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn()
     # rd = tables.Column(verbose_name="RD")
@@ -232,6 +232,7 @@ class VRFTable(BaseTable):
             "pk",
             "name",
             # "rd",
+            "status",
             "namespace",
             "tenant",
             "description",
@@ -240,7 +241,7 @@ class VRFTable(BaseTable):
             "tags",
         )
         # default_columns = ("pk", "name", "rd", "namespace", "tenant", "description")
-        default_columns = ("pk", "name", "namespace", "tenant", "description")
+        default_columns = ("pk", "name", "status", "namespace", "tenant", "description")
 
 
 class VRFDeviceAssignmentTable(BaseTable):

nautobot/ipam/templates/ipam/vrf.html

@@ -19,6 +19,10 @@
                     <td>Tenant</td>
                     <td>{{ object.tenant|hyperlinked_object }}</td>
                 </tr>
+                <tr>
+                    <td>Status</td>
+                    <td>{{ object.status|hyperlinked_object_with_color }}</td>
+                </tr>
                 <tr>
                     <td>Description</td>
                     <td>{{ object.description|placeholder }}</td>

nautobot/ipam/templates/ipam/vrf_edit.html

@@ -8,6 +8,7 @@
             {% render_field form.name %}
             {% render_field form.namespace %}
 	        {% render_field form.rd %}
+            {% render_field form.status %}
             {% render_field form.description %}
         </div>
     </div>