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

nautobot/extras/migrations/0118_task_queue_to_job_queue_migration.py

@@ -0,0 +1,78 @@
+# Generated by Django 4.2.15 on 2024-08-20 14:58
+
+from django.db import migrations
+
+from nautobot.extras.choices import JobQueueTypeChoices
+
+
+def migrate_task_queues_to_job_queues(apps, schema):
+    # Get the relevant models
+    Job = apps.get_model("extras", "Job")
+    ScheduledJob = apps.get_model("extras", "ScheduledJob")
+    JobQueue = apps.get_model("extras", "JobQueue")
+
+    # should always create default job queue
+    JobQueue.objects.get_or_create(name="default", defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY})
+    for job in Job.objects.all():
+        task_queues = job.task_queues
+        if len(task_queues) > 0:
+            default_job_queue, _ = JobQueue.objects.get_or_create(
+                name=task_queues[0], defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+            )
+        else:
+            default_job_queue = JobQueue.objects.get(name="default")
+        job.default_job_queue = default_job_queue
+        job.save()
+        # Go through each task_queue
+        # make or get the corresponding job_queue object and assign it to the job
+        job_queues = [job.default_job_queue]
+        for task_queue in task_queues[1:]:
+            job_queue, _ = JobQueue.objects.get_or_create(
+                name=task_queue, defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+            )
+            job_queues.append(job_queue)
+        job.job_queues.set(job_queues)
+
+    for sj in ScheduledJob.objects.all():
+        queue = sj.queue
+        job_queue = None
+        if queue:
+            job_queue, _ = JobQueue.objects.get_or_create(
+                name=queue, defaults={"queue_type": JobQueueTypeChoices.TYPE_CELERY}
+            )
+        sj.job_queue = job_queue
+        sj.save()
+
+
+def reverse_migrate_task_queues_to_job_queues(apps, schema):
+    Job = apps.get_model("extras", "Job")
+    ScheduledJob = apps.get_model("extras", "ScheduledJob")
+    JobQueueAssignment = apps.get_model("extras", "JobQueueAssignment")
+
+    for job in Job.objects.all():
+        queue_names = list(job.job_queues.all().values_list("name", flat=True))
+        job.task_queues = queue_names
+        job.save()
+    JobQueueAssignment.objects.all().delete()
+
+    for sj in ScheduledJob.objects.all():
+        job_queue = sj.job_queue
+        if job_queue:
+            sj.queue = job_queue.name
+        else:
+            sj.queue = ""
+        sj.job_queue = None
+        sj.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0117_create_job_queue_model"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            code=migrate_task_queues_to_job_queues,
+            reverse_code=reverse_migrate_task_queues_to_job_queues,
+        )
+    ]

nautobot/extras/migrations/0119_remove_task_queues_from_job_and_queue_from_scheduled_job.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.15 on 2024-08-28 15:49
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0118_task_queue_to_job_queue_migration"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="job",
+            name="task_queues",
+        ),
+        migrations.RemoveField(
+            model_name="scheduledjob",
+            name="queue",
+        ),
+        migrations.AlterField(
+            model_name="job",
+            name="default_job_queue",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.PROTECT, related_name="default_for_jobs", to="extras.jobqueue"
+            ),
+        ),
+    ]

nautobot/extras/migrations/0120_job_is_singleton_job_is_singleton_override.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.16 on 2024-11-11 07:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0119_remove_task_queues_from_job_and_queue_from_scheduled_job"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="job",
+            name="is_singleton",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="job",
+            name="is_singleton_override",
+            field=models.BooleanField(default=False),
+        ),
+    ]

nautobot/extras/migrations/0121_alter_team_contacts.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.16 on 2024-12-03 15:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0120_job_is_singleton_job_is_singleton_override"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="team",
+            name="contacts",
+            field=models.ManyToManyField(blank=True, related_name="teams", to="extras.contact"),
+        ),
+    ]

nautobot/extras/models/__init__.py

@@ -8,6 +8,8 @@ from .jobs import (
     JobButton,
     JobHook,
     JobLogEntry,
+    JobQueue,
+    JobQueueAssignment,
     JobResult,
     ScheduledJob,
     ScheduledJobs,
@@ -66,6 +68,8 @@ __all__ = (
     "JobButton",
     "JobHook",
     "JobLogEntry",
+    "JobQueue",
+    "JobQueueAssignment",
     "JobResult",
     "MetadataChoice",
     "MetadataType",
@@ -73,8 +77,8 @@ __all__ = (
     "ObjectChange",
     "ObjectMetadata",
     "Relationship",
-    "RelationshipModel",
     "RelationshipAssociation",
+    "RelationshipModel",
     "Role",
     "RoleField",
     "SavedView",

nautobot/extras/models/change_logging.py

@@ -169,14 +169,18 @@ class ObjectChange(BaseModel):
     def get_action_class(self):
         return ObjectChangeActionChoices.CSS_CLASSES.get(self.action)
 
-    def get_next_change(self, user=None):
+    def get_next_change(self, user=None, only=None):
         """Return next change for this changed object, optionally restricting by user view permission"""
         related_changes = self.get_related_changes(user=user)
+        if only:
+            related_changes = related_changes.only(*only)
         return related_changes.filter(time__gt=self.time).order_by("time").first()
 
-    def get_prev_change(self, user=None):
+    def get_prev_change(self, user=None, only=None):
         """Return previous change for this changed object, optionally restricting by user view permission"""
         related_changes = self.get_related_changes(user=user)
+        if only:
+            related_changes = related_changes.only(*only)
         return related_changes.filter(time__lt=self.time).order_by("-time").first()
 
     def get_related_changes(self, user=None, permission="view"):
@@ -207,7 +211,7 @@ class ObjectChange(BaseModel):
         prechange = None
         postchange = None
 
-        prior_change = self.get_prev_change()
+        prior_change = self.get_prev_change(only=["object_data_v2", "object_data"])
 
         if self.action != ObjectChangeActionChoices.ACTION_CREATE and prior_change is not None:
             prechange = prior_change.object_data_v2

nautobot/extras/models/contacts.py

@@ -61,7 +61,7 @@ class Contact(ContactTeamSharedBase):
 class Team(ContactTeamSharedBase):
     """A group of Contacts, usable interchangeably with a single Contact in most cases."""
 
-    contacts = models.ManyToManyField(to=Contact, related_name="teams")
+    contacts = models.ManyToManyField(to=Contact, related_name="teams", blank=True)
 
     class Meta(ContactTeamSharedBase.Meta):
         abstract = False

nautobot/extras/models/groups.py

@@ -1,7 +1,5 @@
 """Dynamic Groups Models."""
 
-from __future__ import annotations  # python 3.8
-
 import logging
 from typing import Optional
 

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
@@ -135,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(
@@ -164,17 +174,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 +232,18 @@ 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",
+    )
+    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"
@@ -302,6 +328,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 +370,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 +539,77 @@ 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):
+        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})"
+
+
+@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
 #
@@ -616,7 +748,7 @@ class JobResult(BaseModel, CustomFieldModel):
                 )
 
     @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 +760,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 +768,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 +788,12 @@ class JobResult(BaseModel, CustomFieldModel):
         profile=False,
         schedule=None,
         task_queue=None,
+        job_result=None,
         synchronous=False,
+        ignore_singleton_lock=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,7 +802,11 @@ 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.
+            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
 
@@ -672,20 +818,40 @@ 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,
             "nautobot_job_profile": profile,
             "nautobot_job_user_id": user.id,
+            "nautobot_job_ignore_singleton_lock": ignore_singleton_lock,
             "queue": task_queue,
         }
 
@@ -712,12 +878,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 +906,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 +1111,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 +1249,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)
@@ -1108,6 +1305,7 @@ class ScheduledJob(BaseModel):
         profile=False,
         approval_required=False,
         task_queue=None,
+        ignore_singleton_lock=False,
         **job_kwargs,
     ):
         """
@@ -1128,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:
@@ -1146,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