nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/extras/models/jobs.py

@@ -2,8 +2,11 @@
 
 import contextlib
 from datetime import timedelta
+import json
 import logging
+import signal
 
+from billiard.exceptions import SoftTimeLimitExceeded
 from celery.exceptions import NotRegistered
 from celery.utils.log import get_logger, LoggingProxy
 from django.conf import settings
@@ -26,12 +29,12 @@ from nautobot.core.celery import (
 )
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models import BaseManager, BaseModel
-from nautobot.core.models.fields import JSONArrayField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.utils.logging import sanitize
 from nautobot.extras.choices import (
     ButtonClassChoices,
     JobExecutionType,
+    JobQueueTypeChoices,
     JobResultStatusChoices,
     LogLevelChoices,
 )
@@ -49,6 +52,8 @@ from nautobot.extras.querysets import JobQuerySet, ScheduledJobExtendedQuerySet
 from nautobot.extras.utils import (
     ChangeLoggedModelsQuery,
     extras_features,
+    get_job_queue_worker_count,
+    run_kubernetes_job_and_return_job_result,
 )
 
 from .customfields import CustomFieldModel
@@ -164,17 +169,26 @@ class Job(PrimaryModel):
         help_text="Maximum runtime in seconds before the job will be forcibly terminated."
         "<br>Set to 0 to use Nautobot system default",
     )
-    task_queues = JSONArrayField(
-        base_field=models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True),
-        default=list,
-        blank=True,
-        help_text="Comma separated list of task queues that this job can run on. A blank list will use the default queue",
-    )
     supports_dryrun = models.BooleanField(
         default=False,
         editable=False,
         help_text="If supported, allows the job to bypass approval when running with dryrun argument set to true",
     )
+    job_queues = models.ManyToManyField(
+        to="extras.JobQueue",
+        related_name="jobs",
+        verbose_name="Job Queues",
+        help_text="The job queues that this job can be run on",
+        through="extras.JobQueueAssignment",
+    )
+    default_job_queue = models.ForeignKey(
+        to="extras.JobQueue",
+        related_name="default_for_jobs",
+        on_delete=models.PROTECT,
+        verbose_name="Default Job Queue",
+        null=False,
+        blank=False,
+    )
 
     # Flags to indicate whether the above properties are inherited from the source code or overridden by the database
     grouping_override = models.BooleanField(
@@ -213,11 +227,14 @@ class Job(PrimaryModel):
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
-    task_queues_override = models.BooleanField(
+    job_queues_override = models.BooleanField(
+        default=False,
+        help_text="If set, the configured value will remain even if the underlying Job source code changes",
+    )
+    default_job_queue_override = models.BooleanField(
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
-
     objects = BaseManager.from_queryset(JobQuerySet)()
 
     documentation_static_path = "docs/user-guide/platform-functionality/jobs/models.html"
@@ -234,13 +251,13 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
-    def delete(self, *args, **kwargs):
+    def delete(self):
         if self.module_name.startswith("nautobot."):
             raise ProtectedError(
                 f"Unable to delete Job {self}. System Job cannot be deleted",
                 [],
             )
-        super().delete(*args, **kwargs)
+        super().delete()
 
     @property
     def job_class(self):
@@ -302,6 +319,38 @@ class Job(PrimaryModel):
         except TypeError as err:  # keep 2.0-2.2.2 exception behavior
             raise NotRegistered from err
 
+    @property
+    def task_queues(self):
+        """Deprecated backward-compatibility property for the list of queue names for this Job."""
+        return self.job_queues.values_list("name", flat=True)
+
+    @task_queues.setter
+    def task_queues(self, value):
+        job_queues = []
+        # value is going to be a comma separated list of queue names
+        if isinstance(value, str):
+            value = value.split(",")
+        for queue in value:
+            try:
+                job_queues.append(JobQueue.objects.get(name=queue))
+            except JobQueue.DoesNotExist:
+                raise ValidationError(f"Job Queue {queue} does not exist in the database.")
+        self.job_queues.set(job_queues)
+
+    @property
+    def task_queues_override(self):
+        return self.job_queues_override
+
+    @task_queues_override.setter
+    def task_queues_override(self, value):
+        if isinstance(value, bool):
+            raise ValidationError(
+                {
+                    "task_queues_override": f"{value} is invalid for field task_queues_override, use a boolean value instead"
+                }
+            )
+        self.job_queues_override = value
+
     def clean(self):
         """For any non-overridden fields, make sure they get reset to the actual underlying class value if known."""
         from nautobot.extras.jobs import get_job
@@ -312,6 +361,9 @@ class Job(PrimaryModel):
                 if not getattr(self, f"{field_name}_override", False):
                     setattr(self, field_name, getattr(job_class, field_name))
 
+            if not self.job_queues_override:
+                self.task_queues = job_class.task_queues or [settings.CELERY_TASK_DEFAULT_QUEUE]
+
         # Protect against invalid input when auto-creating Job records
         if len(self.module_name) > JOB_MAX_NAME_LENGTH:
             raise ValidationError(f"Module name may not exceed {JOB_MAX_NAME_LENGTH} characters in length")
@@ -478,6 +530,75 @@ class JobLogEntry(BaseModel):
         verbose_name_plural = "job log entries"
 
 
+#
+# Job Queues
+#
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+    "webhooks",
+)
+class JobQueue(PrimaryModel):
+    """
+    A Job Queue represents a structure that is used to manage, organize and schedule jobs for Nautobot workers.
+    """
+
+    name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
+    description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
+    queue_type = models.CharField(
+        max_length=50,
+        choices=JobQueueTypeChoices,
+    )
+    tenant = models.ForeignKey(
+        to="tenancy.Tenant",
+        on_delete=models.PROTECT,
+        related_name="job_queues",
+        blank=True,
+        null=True,
+    )
+
+    documentation_static_path = "docs/user-guide/platform-functionality/jobs/jobqueue.html"
+
+    class Meta:
+        ordering = ["name"]
+
+    def __str__(self):
+        return f"{self.queue_type}: {self.name}"
+
+    @property
+    def display(self):
+        worker_count = get_job_queue_worker_count(job_queue=self)
+        workers = "worker" if worker_count == 1 else "workers"
+        return f"{self.queue_type}: {self.name} ({worker_count} {workers})"
+
+
+@extras_features(
+    "custom_links",
+    "custom_validators",
+    "export_templates",
+    "graphql",
+)
+class JobQueueAssignment(BaseModel):
+    """
+    Through table model that represents the m2m relationship between jobs and job queues.
+    """
+
+    job = models.ForeignKey(Job, on_delete=models.CASCADE, related_name="job_queue_assignments")
+    job_queue = models.ForeignKey(JobQueue, on_delete=models.CASCADE, related_name="job_assignments")
+    is_metadata_associable_model = False
+
+    class Meta:
+        unique_together = ["job", "job_queue"]
+        ordering = ["job", "job_queue"]
+
+    def __str__(self):
+        return f"{self.job}: {self.job_queue}"
+
+
 #
 # Job results
 #
@@ -610,13 +731,13 @@ class JobResult(BaseModel, CustomFieldModel):
             # Only add metrics if we have a related job model. If we are moving to a terminal state we should always
             # have a related job model, so this shouldn't be too tight of a restriction.
             if self.job_model:
-                duration = self.date_done - self.date_created
+                duration = self.date_done - self.created
                 JOB_RESULT_METRIC.labels(self.job_model.grouping, self.job_model.name, status).observe(
                     duration.total_seconds()
                 )
 
     @classmethod
-    def execute_job(cls, job_model, user, *job_args, celery_kwargs=None, profile=False, **job_kwargs):
+    def execute_job(cls, job_model, user, *job_args, celery_kwargs=None, profile=False, job_result=None, **job_kwargs):
         """
         Create a JobResult instance and run a job in the current process, blocking until the job finishes.
 
@@ -628,6 +749,7 @@ class JobResult(BaseModel, CustomFieldModel):
             user (User): User object to link to the JobResult instance
             celery_kwargs (dict, optional): Dictionary of kwargs to pass as **kwargs to Celery when job is run
             profile (bool, optional): Whether to run cProfile on the job execution
+            job_result (JobResult, optional): Existing JobResult with status PENDING, used in kubernetes job execution
             *job_args: positional args passed to the job task
             **job_kwargs: keyword args passed to the job task
 
@@ -635,7 +757,14 @@ class JobResult(BaseModel, CustomFieldModel):
             JobResult instance
         """
         return cls.enqueue_job(
-            job_model, user, *job_args, celery_kwargs=celery_kwargs, profile=profile, synchronous=True, **job_kwargs
+            job_model,
+            user,
+            *job_args,
+            celery_kwargs=celery_kwargs,
+            profile=profile,
+            job_result=job_result,
+            synchronous=True,
+            **job_kwargs,
         )
 
     @classmethod
@@ -648,10 +777,11 @@ class JobResult(BaseModel, CustomFieldModel):
         profile=False,
         schedule=None,
         task_queue=None,
+        job_result=None,
         synchronous=False,
         **job_kwargs,
     ):
-        """Create a JobResult instance and enqueue a job to be executed asynchronously by a Celery worker.
+        """Create/Modify a JobResult instance and enqueue a job to be executed asynchronously by a Celery worker.
 
         Args:
             job_model (Job): The Job to be enqueued for execution.
@@ -660,6 +790,7 @@ class JobResult(BaseModel, CustomFieldModel):
             profile (bool, optional): If True, dump cProfile stats on the job execution.
             schedule (ScheduledJob, optional): ScheduledJob instance to link to the JobResult. Cannot be used with synchronous=True.
             task_queue (str, optional): The celery queue to send the job to. If not set, use the default celery queue.
+            job_result (JobResult, optional): Existing JobResult with status PENDING, to be modified and to be used in kubernetes job execution.
             synchronous (bool, optional): If True, run the job in the current process, blocking until the job completes.
             *job_args: positional args passed to the job task (UNUSED)
             **job_kwargs: keyword args passed to the job task
@@ -672,15 +803,34 @@ class JobResult(BaseModel, CustomFieldModel):
         if schedule is not None and synchronous:
             raise ValueError("Scheduled jobs cannot be run synchronously")
 
-        job_result = cls.objects.create(
-            name=job_model.name,
-            job_model=job_model,
-            scheduled_job=schedule,
-            user=user,
-        )
+        if job_result is None:
+            job_result = cls.objects.create(
+                name=job_model.name,
+                job_model=job_model,
+                scheduled_job=schedule,
+                user=user,
+            )
+        else:
+            if job_result.user != user:
+                raise ValueError(
+                    f"There is a mismatch between the user specified {user} and the user associated with the job result {job_result.user}"
+                )
+            if job_result.job_model != job_model:
+                raise ValueError(
+                    f"There is a mismatch between the job specified {job_model} and the job associated with the job result {job_result.job_model}"
+                )
 
         if task_queue is None:
-            task_queue = settings.CELERY_TASK_DEFAULT_QUEUE
+            task_queue = job_model.default_job_queue.name
+
+        job_queue = JobQueue.objects.get(name=task_queue)
+        # Kubernetes Job Queue logic
+        # As we execute Kubernetes jobs, we want to execute `run_kubernetes_job_and_return_job_result`
+        # the first time the kubernetes job is enqueued to spin up the kubernetes pod.
+        # And from the kubernetes pod, we specify "--local"/synchronous=True
+        # so that `run_kubernetes_job_and_return_job_result` is not executed again and the job will be run locally.
+        if job_queue.queue_type == JobQueueTypeChoices.TYPE_KUBERNETES and not synchronous:
+            return run_kubernetes_job_and_return_job_result(job_queue, job_result, json.dumps(job_kwargs))
 
         job_celery_kwargs = {
             "nautobot_job_job_model_id": job_model.id,
@@ -712,12 +862,24 @@ class JobResult(BaseModel, CustomFieldModel):
             redirect_logger = get_logger("celery.redirected")
             proxy = LoggingProxy(redirect_logger, app.conf.worker_redirect_stdouts_level)
             with contextlib.redirect_stdout(proxy), contextlib.redirect_stderr(proxy):
-                eager_result = run_job.apply(
-                    args=[job_model.class_path, *job_args],
-                    kwargs=job_kwargs,
-                    task_id=str(job_result.id),
-                    **job_celery_kwargs,
-                )
+
+                def alarm_handler(*args, **kwargs):
+                    raise SoftTimeLimitExceeded()
+
+                # Set alarm_handler to be called on a SIGALRM, and schedule a SIGALRM based on the soft time limit
+                signal.signal(signal.SIGALRM, alarm_handler)
+                signal.alarm(int(job_model.soft_time_limit) or settings.CELERY_TASK_SOFT_TIME_LIMIT)
+
+                try:
+                    eager_result = run_job.apply(
+                        args=[job_model.class_path, *job_args],
+                        kwargs=job_kwargs,
+                        task_id=str(job_result.id),
+                        **job_celery_kwargs,
+                    )
+                finally:
+                    # Cancel the scheduled SIGALRM if it hasn't fired already
+                    signal.alarm(0)
 
             # copy fields from eager result to job result
             job_result.refresh_from_db()
@@ -728,9 +890,15 @@ class JobResult(BaseModel, CustomFieldModel):
                     "exc_message": sanitize(str(eager_result.result)),
                 }
             else:
-                job_result.result = sanitize(eager_result.result)
+                if eager_result.result is not None:
+                    job_result.result = sanitize(eager_result.result)
+                else:
+                    job_result.result = None
             job_result.status = eager_result.status
-            job_result.traceback = sanitize(eager_result.traceback)
+            if eager_result.traceback is not None:
+                job_result.traceback = sanitize(eager_result.traceback)
+            else:
+                job_result.traceback = None
             job_result.date_done = timezone.now()
             job_result.save()
         else:
@@ -927,13 +1095,13 @@ class ScheduledJob(BaseModel):
     args = models.JSONField(blank=True, default=list, encoder=NautobotKombuJSONEncoder)
     kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
     celery_kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
-    queue = models.CharField(
-        max_length=CHARFIELD_MAX_LENGTH,
+    job_queue = models.ForeignKey(
+        to="extras.JobQueue",
+        on_delete=models.SET_NULL,
+        related_name="scheduled_jobs",
+        null=True,
         blank=True,
-        default="",
-        verbose_name="Queue Override",
-        help_text="Queue defined in CELERY_TASK_QUEUES. Leave empty for default queuing.",
-        db_index=True,
+        verbose_name="Job Queue Override",
     )
     one_off = models.BooleanField(
         default=False,
@@ -1065,6 +1233,19 @@ class ScheduledJob(BaseModel):
 
         return self.to_cron()
 
+    @property
+    def queue(self):
+        """Deprecated backward-compatibility property for the queue name this job is scheduled for."""
+        return self.job_queue.name if self.job_queue else ""
+
+    @queue.setter
+    def queue(self, value):
+        if value:
+            try:
+                self.job_queue = JobQueue.objects.get(name=value)
+            except JobQueue.DoesNotExist:
+                raise ValidationError(f"Job Queue {value} does not exist in the database.")
+
     @staticmethod
     def earliest_possible_time():
         return timezone.now() + timedelta(seconds=15)
@@ -1180,7 +1361,7 @@ class ScheduledJob(BaseModel):
 
     def to_cron(self):
         tz = self.time_zone
-        t = self.start_time.astimezone(tz)  # pylint: disable=no-member
+        t = self.start_time.astimezone(tz)
         if self.interval == JobExecutionType.TYPE_HOURLY:
             return TzAwareCrontab(minute=t.minute, tz=tz)
         elif self.interval == JobExecutionType.TYPE_DAILY:

nautobot/extras/models/models.py

@@ -207,7 +207,7 @@ class ConfigContextModel(models.Model, ConfigContextSchemaValidationMixin):
             # Annotation not available, so fall back to manually querying for the config context
             config_context_data = ConfigContext.objects.get_for_object(self).values_list("data", flat=True)
         else:
-            config_context_data = self.config_context_data or []  # pylint: disable=no-member
+            config_context_data = self.config_context_data or []
             config_context_data = [
                 c["data"] for c in sorted(config_context_data, key=lambda k: (k["weight"], k["name"]))
             ]
@@ -831,7 +831,7 @@ class Note(ChangeLoggedModel, BaseModel):
         unique_together = [["assigned_object_type", "assigned_object_id", "user_name", "created"]]
 
     def __str__(self):
-        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"  # pylint: disable=no-member
+        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"
 
     def save(self, *args, **kwargs):
         # Record the user's name as static strings

nautobot/extras/models/relationships.py

@@ -105,7 +105,7 @@ class RelationshipModel(models.Model):
 
                 # Determine if the relationship is applicable to this object based on the filter
                 # To resolve the filter we are using the FilterSet for the given model
-                # If there is no match when we query the primary key of the device along with the filter
+                # If there is no match when we query our id along with the filter
                 # Then the relationship is not applicable to this object
                 if getattr(relationship, f"{side}_filter"):
                     filterset = get_filterset_for_model(self._meta.model)
@@ -222,6 +222,74 @@ class RelationshipModel(models.Model):
         """
         return self.get_relationships_data(advanced_ui=True)
 
+    def get_relationships_with_related_objects(self, include_hidden=False, advanced_ui=None):
+        """Alternative version of get_relationships()."""
+        src_relationships, dst_relationships = Relationship.objects.get_for_model(self)
+
+        if advanced_ui is not None:
+            src_relationships = src_relationships.filter(advanced_ui=advanced_ui)
+            dst_relationships = dst_relationships.filter(advanced_ui=advanced_ui)
+
+        resp = {
+            RelationshipSideChoices.SIDE_SOURCE: {},
+            RelationshipSideChoices.SIDE_DESTINATION: {},
+            RelationshipSideChoices.SIDE_PEER: {},
+        }
+
+        for side, relationships in (
+            (RelationshipSideChoices.SIDE_SOURCE, src_relationships),
+            (RelationshipSideChoices.SIDE_DESTINATION, dst_relationships),
+        ):
+            peer_side = RelationshipSideChoices.OPPOSITE[side]
+            for relationship in relationships:
+                if getattr(relationship, f"{side}_hidden") and not include_hidden:
+                    continue
+
+                # Determine if the relationship is applicable to this object based on the filter
+                # To resolve the filter we are using the FilterSet for the given model
+                # If there is no match when we query our id along with the filter
+                # Then the relationship is not applicable to this object
+                if getattr(relationship, f"{side}_filter"):
+                    filterset = get_filterset_for_model(self._meta.model)
+                    if filterset:
+                        filter_params = getattr(relationship, f"{side}_filter")
+                        if not filterset(filter_params, self._meta.model.objects.filter(id=self.id)).qs.exists():
+                            continue
+
+                # Construct the queryset for related objects for this relationship
+                remote_ct = getattr(relationship, f"{peer_side}_type")
+                remote_model = remote_ct.model_class()
+                if remote_model is not None:
+                    if not relationship.symmetric:
+                        query_params = {f"{peer_side}_for_associations__relationship": relationship.pk}
+                        resp[side][relationship] = remote_model.objects.filter(**query_params)
+                        if not relationship.has_many(peer_side):
+                            resp[side][relationship] = resp[side][relationship].first()
+                    else:
+                        resp[RelationshipSideChoices.SIDE_PEER][relationship] = remote_model.objects.filter(
+                            Q(source_for_associations__relationship=relationship.pk)
+                            | Q(destination_for_associations__relationship=relationship.pk)
+                        ).exclude(pk=self.pk)
+                        if not relationship.has_many(peer_side):
+                            resp[side][relationship] = resp[side][relationship].first()
+                else:
+                    # Maybe an uninstalled App?
+                    # We can't provide a relevant queryset, but we can provide a descriptive string
+                    if not relationship.symmetric:
+                        count = RelationshipAssociation.objects.filter(
+                            relationship=relationship, **{f"{side}_id": self.pk}
+                        ).count()
+                        resp[side][relationship] = f"{count} {remote_ct} object(s)"
+                    else:
+                        count = (
+                            RelationshipAssociation.objects.filter(relationship=relationship)
+                            .filter(Q(source_id=self.pk) | Q(destination_id=self.pk))
+                            .count()
+                        )
+                        resp[RelationshipSideChoices.SIDE_PEER][relationship] = f"{count} {remote_ct} object(s)"
+
+        return resp
+
     @classmethod
     def required_related_objects_errors(
         cls, output_for="ui", initial_data=None, relationships_key_specified=False, instance=None

nautobot/extras/models/secrets.py

@@ -46,6 +46,11 @@ class Secret(PrimaryModel):
     def __str__(self):
         return self.name
 
+    def get_provider_display(self):
+        if provider := registry["secrets_providers"].get(self.provider):
+            return provider.name
+        return self.provider
+
     def rendered_parameters(self, obj=None):
         """Render self.parameters as a Jinja2 template with the given object as context."""
         try: