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

nautobot/extras/models/jobs.py

@@ -140,6 +140,11 @@ class Job(PrimaryModel):
         default=True, help_text="Whether this job contains sensitive variables"
     )
 
+    is_singleton = models.BooleanField(
+        default=False,
+        help_text="Whether this job should fail to run if another instance of this job is already running",
+    )
+
     # Additional properties, potentially inherited from the source code
     # See also the docstring of nautobot.extras.jobs.BaseJob.Meta.
     approval_required = models.BooleanField(
@@ -235,6 +240,10 @@ class Job(PrimaryModel):
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
+    is_singleton_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"
@@ -251,13 +260,13 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
-    def delete(self):
+    def delete(self, *args, **kwargs):
         if self.module_name.startswith("nautobot."):
             raise ProtectedError(
                 f"Unable to delete Job {self}. System Job cannot be deleted",
                 [],
             )
-        super().delete()
+        super().delete(*args, **kwargs)
 
     @property
     def job_class(self):
@@ -571,6 +580,8 @@ class JobQueue(PrimaryModel):
 
     @property
     def display(self):
+        if self.queue_type != JobQueueTypeChoices.TYPE_CELERY:
+            return f"{self.queue_type}: {self.name}"
         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})"
@@ -731,7 +742,7 @@ 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.created
+                duration = self.date_done - self.date_created
                 JOB_RESULT_METRIC.labels(self.job_model.grouping, self.job_model.name, status).observe(
                     duration.total_seconds()
                 )
@@ -779,6 +790,7 @@ class JobResult(BaseModel, CustomFieldModel):
         task_queue=None,
         job_result=None,
         synchronous=False,
+        ignore_singleton_lock=False,
         **job_kwargs,
     ):
         """Create/Modify a JobResult instance and enqueue a job to be executed asynchronously by a Celery worker.
@@ -792,6 +804,9 @@ class JobResult(BaseModel, CustomFieldModel):
             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.
+            ignore_singleton_lock (bool, optional): If True, invalidate the singleton lock before running the job.
+              This allows singleton jobs to run twice, or makes it possible to remove the lock when the first instance
+              of the job failed to remove it for any reason.
             *job_args: positional args passed to the job task (UNUSED)
             **job_kwargs: keyword args passed to the job task
 
@@ -836,6 +851,7 @@ class JobResult(BaseModel, CustomFieldModel):
             "nautobot_job_job_model_id": job_model.id,
             "nautobot_job_profile": profile,
             "nautobot_job_user_id": user.id,
+            "nautobot_job_ignore_singleton_lock": ignore_singleton_lock,
             "queue": task_queue,
         }
 
@@ -1289,6 +1305,7 @@ class ScheduledJob(BaseModel):
         profile=False,
         approval_required=False,
         task_queue=None,
+        ignore_singleton_lock=False,
         **job_kwargs,
     ):
         """
@@ -1309,6 +1326,7 @@ class ScheduledJob(BaseModel):
             profile (bool, optional): Flag indicating whether to profile the job. Defaults to False.
             approval_required (bool, optional): Flag indicating if approval is required. Defaults to False.
             task_queue (str, optional): The task queue for the job. Defaults to None, which will use the configured default celery queue.
+            ignore_singleton_lock (bool, optional): Flag indicating whether to ignore singleton locks. Defaults to False.
             **job_kwargs: Additional keyword arguments to pass to the job.
 
         Returns:
@@ -1327,6 +1345,7 @@ class ScheduledJob(BaseModel):
         celery_kwargs = {
             "nautobot_job_profile": profile,
             "queue": task_queue,
+            "nautobot_job_ignore_singleton_lock": ignore_singleton_lock,
         }
         if job_model.soft_time_limit > 0:
             celery_kwargs["soft_time_limit"] = job_model.soft_time_limit
@@ -1361,7 +1380,7 @@ class ScheduledJob(BaseModel):
 
     def to_cron(self):
         tz = self.time_zone
-        t = self.start_time.astimezone(tz)
+        t = self.start_time.astimezone(tz)  # pylint: disable=no-member
         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 []
+            config_context_data = self.config_context_data or []  # pylint: disable=no-member
             config_context_data = [
                 c["data"] for c in sorted(config_context_data, key=lambda k: (k["weight"], k["name"]))
             ]
@@ -680,6 +680,21 @@ class GraphQLQuery(
     SavedViewMixin,
     BaseModel,
 ):
+    # A Graphql Query *may* be owned by another model, such as a GitRepository, or it may be un-owned
+    owner_content_type = models.ForeignKey(
+        to=ContentType,
+        on_delete=models.CASCADE,
+        limit_choices_to=FeatureQuery("graphql_query_owners"),
+        default=None,
+        null=True,
+        blank=True,
+        related_name="graphql_queries",
+    )
+    owner_object_id = models.UUIDField(default=None, null=True, blank=True)
+    owner = GenericForeignKey(
+        ct_field="owner_content_type",
+        fk_field="owner_object_id",
+    )
     name = models.CharField(max_length=CHARFIELD_MAX_LENGTH, unique=True)
     query = models.TextField()
     variables = models.JSONField(encoder=DjangoJSONEncoder, default=dict, blank=True)
@@ -831,7 +846,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}"
+        return f"{self.assigned_object} - {self.created.isoformat() if self.created else None}"  # pylint: disable=no-member
 
     def save(self, *args, **kwargs):
         # Record the user's name as static strings

nautobot/extras/models/relationships.py

@@ -261,15 +261,27 @@ class RelationshipModel(models.Model):
                 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)
+                        query_params = {
+                            f"{peer_side}_for_associations__relationship": relationship,
+                            f"{peer_side}_for_associations__{side}_id": self.pk,
+                        }
+                        # Get the related objects for this relationship on the opposite side.
+                        resp[side][relationship] = remote_model.objects.filter(**query_params).distinct()
                         if not relationship.has_many(peer_side):
                             resp[side][relationship] = resp[side][relationship].first()
                     else:
+                        side_query_params = {
+                            f"{peer_side}_for_associations__relationship": relationship,
+                            f"{peer_side}_for_associations__{side}_id": self.pk,
+                        }
+                        peer_side_query_params = {
+                            f"{side}_for_associations__relationship": relationship,
+                            f"{side}_for_associations__{peer_side}_id": self.pk,
+                        }
+                        # Get the related objects based on the pks we gathered.
                         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)
+                            Q(**side_query_params) | Q(**peer_side_query_params)
+                        ).distinct()
                         if not relationship.has_many(peer_side):
                             resp[side][relationship] = resp[side][relationship].first()
                 else:

nautobot/extras/plugins/__init__.py

@@ -554,6 +554,7 @@ class TableExtension:
     """
 
     model = None
+    suffix = None
     table_columns = {}
     add_to_default_columns = ()
     remove_from_default_columns = ()
@@ -629,7 +630,7 @@ def _add_columns_into_model_table(table_extension, app_name):
         logger.error(error)
         return
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     for name, column in table_extension.table_columns.items():
         _validate_table_column_name_is_prefixed_with_app_name(name, app_name)
         _add_column_to_table_base_columns(table, name, column, app_name)
@@ -664,18 +665,28 @@ def _modify_default_table_columns(table_extension, app_name):
     """Add or remove columns from the table default columns."""
     from nautobot.core.utils.lookup import get_table_for_model
 
-    table = get_table_for_model(table_extension.model)
+    table = get_table_for_model(table_extension.model, suffix=table_extension.suffix)
     message = (
         f"{app_name}: Cannot {{action}} column `{{column_name}}` {{preposition}} the default columns for `{table}`."
     )
 
     for column_name in table_extension.add_to_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot add column: {column_name}."
+            )
+            continue
         if column_name in table.base_columns:
             table.Meta.default_columns = (*table.Meta.default_columns, column_name)
         else:
             logger.debug(message.format(action="add", column_name=column_name, preposition="to"))
 
     for column_name in table_extension.remove_from_default_columns:
+        if not getattr(table.Meta, "default_columns", None):
+            logger.warning(
+                f"{app_name}: Table `{table}` does not have a `default_columns` attribute. Cannot remove column: {column_name}."
+            )
+            continue
         if column_name in table.Meta.default_columns:
             table.Meta.default_columns = tuple(name for name in table.Meta.default_columns if name != column_name)
         else: