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

nautobot/extras/graphql/types.py

@@ -1,11 +1,15 @@
+import graphene
+
 from nautobot.core.graphql.types import OptimizedNautobotObjectType
 from nautobot.extras.filters import (
     ContactAssociationFilterSet,
     DynamicGroupFilterSet,
+    JobFilterSet,
+    ScheduledJobFilterSet,
     StatusFilterSet,
     TagFilterSet,
 )
-from nautobot.extras.models import ContactAssociation, DynamicGroup, Status, Tag
+from nautobot.extras.models import ContactAssociation, DynamicGroup, Job, ScheduledJob, Status, Tag
 
 
 class ContactAssociationType(OptimizedNautobotObjectType):
@@ -24,6 +28,26 @@ class DynamicGroupType(OptimizedNautobotObjectType):
         filterset_class = DynamicGroupFilterSet
 
 
+class JobType(OptimizedNautobotObjectType):
+    """Graphql Type Object for Job model."""
+
+    class Meta:
+        model = Job
+        filterset_class = JobFilterSet
+
+    task_queues = graphene.List(graphene.String)
+
+
+class ScheduledJobType(OptimizedNautobotObjectType):
+    """Graphql Type Object for Job model."""
+
+    class Meta:
+        model = ScheduledJob
+        filterset_class = ScheduledJobFilterSet
+
+    queue = graphene.String
+
+
 class StatusType(OptimizedNautobotObjectType):
     """Graphql Type object for `Status` model."""
 

nautobot/extras/jobs.py

@@ -18,6 +18,7 @@ from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.core.cache import cache
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
@@ -30,25 +31,32 @@ import netaddr
 import yaml
 
 from nautobot.core.celery import import_jobs, nautobot_task
+from nautobot.core.events import publish_event
 from nautobot.core.forms import (
     DynamicModelChoiceField,
     DynamicModelMultipleChoiceField,
     JSONField,
 )
 from nautobot.core.utils.config import get_settings_or_config
+from nautobot.core.utils.logging import sanitize
 from nautobot.core.utils.lookup import get_model_from_name
-from nautobot.extras.choices import JobResultStatusChoices, ObjectChangeActionChoices, ObjectChangeEventContextChoices
+from nautobot.extras.choices import (
+    JobResultStatusChoices,
+    ObjectChangeActionChoices,
+    ObjectChangeEventContextChoices,
+)
 from nautobot.extras.context_managers import web_request_context
 from nautobot.extras.forms import JobForm
 from nautobot.extras.models import (
     FileProxy,
     Job as JobModel,
     JobHook,
+    JobQueue,
     JobResult,
     ObjectChange,
 )
 from nautobot.extras.registry import registry
-from nautobot.extras.utils import change_logged_models_queryset, task_queues_as_choices
+from nautobot.extras.utils import change_logged_models_queryset
 from nautobot.ipam.formfields import IPAddressFormField, IPNetworkFormField
 from nautobot.ipam.validators import (
     MaxPrefixLengthValidator,
@@ -60,15 +68,15 @@ User = get_user_model()
 
 
 __all__ = [
-    "Job",
     "BooleanVar",
     "ChoiceVar",
     "FileVar",
-    "IntegerVar",
     "IPAddressVar",
     "IPAddressWithMaskVar",
     "IPNetworkVar",
+    "IntegerVar",
     "JSONVar",
+    "Job",
     "MultiChoiceVar",
     "MultiObjectVar",
     "ObjectVar",
@@ -107,6 +115,7 @@ class BaseJob:
         - task_queues (list)
         - template_name (str)
         - time_limit (int)
+        - is_singleton (bool)
         """
 
     def __init__(self):
@@ -184,6 +193,31 @@ class BaseJob:
             )
             raise RunJobTaskFailed(f"Job {self.job_model} is not enabled to be run!")
 
+        ignore_singleton_lock = self.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
+        if self.job_model.is_singleton:
+            is_running = cache.get(self.singleton_cache_key)
+            if is_running:
+                if ignore_singleton_lock:
+                    self.logger.info(
+                        "Job %s is a singleton and already running, but singleton will be ignored because"
+                        " `ignore_singleton_lock` is set.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                else:
+                    self.logger.error(
+                        "Job %s is a singleton and already running.",
+                        self.job_model,
+                        extra={"object": self.job_model, "grouping": "initialization"},
+                    )
+                    raise RunJobTaskFailed(f"Job '{self.job_model}' is a singleton and already running.")
+            cache_parameters = {
+                "key": self.singleton_cache_key,
+                "value": 1,
+                "timeout": self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
+            }
+            cache.set(**cache_parameters)
+
         soft_time_limit = self.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
         time_limit = self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
         if time_limit <= soft_time_limit:
@@ -275,7 +309,15 @@ class BaseJob:
             self._delete_file_proxies(*file_ids)
 
         if status == JobResultStatusChoices.STATUS_SUCCESS:
-            self.logger.info("Job completed", extra={"grouping": "post_run"})
+            self.logger.success("Job completed", extra={"grouping": "post_run"})
+
+        cache.delete(self.singleton_cache_key)
+
+    @final
+    @classproperty
+    def singleton_cache_key(cls) -> str:  # pylint: disable=no-self-argument
+        """Cache key for singleton jobs."""
+        return f"nautobot.extras.jobs.running.{cls.class_path}"
 
     @final
     @classproperty
@@ -396,6 +438,11 @@ class BaseJob:
     def task_queues(cls) -> list:  # pylint: disable=no-self-argument
         return cls._get_meta_attr_and_assert_type("task_queues", [], expected_type=(list, tuple))
 
+    @final
+    @classproperty
+    def is_singleton(cls) -> bool:  # pylint: disable=no-self-argument
+        return cls._get_meta_attr_and_assert_type("is_singleton", False, expected_type=bool)
+
     @final
     @classproperty
     def properties_dict(cls) -> dict:  # pylint: disable=no-self-argument
@@ -414,6 +461,7 @@ class BaseJob:
             "time_limit": cls.time_limit,
             "has_sensitive_variables": cls.has_sensitive_variables,
             "task_queues": cls.task_queues,
+            "is_singleton": cls.is_singleton,
         }
 
     @final
@@ -475,18 +523,41 @@ class BaseJob:
         """
 
         form = cls.as_form_class()(data, files, initial=initial)
-
+        form.fields["_profile"] = forms.BooleanField(
+            required=False,
+            initial=False,
+            label="Profile job execution",
+            help_text="Profiles the job execution using cProfile and outputs a report to /tmp/",
+        )
+        # If the class already exists there may be overrides, so we have to check this.
         try:
-            job_model = JobModel.objects.get_for_class_path(cls.class_path)
-            dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else cls.dryrun_default
-            task_queues = job_model.task_queues if job_model.task_queues_override else cls.task_queues
+            job_model = JobModel.objects.get(module_name=cls.__module__, job_class_name=cls.__name__)
+            is_singleton = job_model.is_singleton
         except JobModel.DoesNotExist:
-            logger.error("No Job instance found in the database corresponding to %s", cls.class_path)
-            dryrun_default = cls.dryrun_default
-            task_queues = cls.task_queues
+            is_singleton = cls.is_singleton
+        if is_singleton:
+            form.fields["_ignore_singleton_lock"] = forms.BooleanField(
+                required=False,
+                initial=False,
+                label="Ignore singleton lock",
+                help_text="Allow this singleton job to run even when another instance is already running",
+            )
 
-        # Update task queue choices
-        form.fields["_task_queue"].choices = task_queues_as_choices(task_queues)
+        job_model = JobModel.objects.get_for_class_path(cls.class_path)
+        dryrun_default = job_model.dryrun_default if job_model.dryrun_default_override else cls.dryrun_default
+        job_queue_queryset = JobQueue.objects.filter(jobs=job_model)
+        job_queue_params = {"jobs": [job_model.pk]}
+
+        # Initialize job_queue choices
+        form.fields["_job_queue"] = DynamicModelChoiceField(
+            queryset=job_queue_queryset,
+            query_params=job_queue_params,
+            required=False,
+            help_text="The job queue to route this job to",
+            label="Job queue",
+        )
+        # Populate the job queue field on the JobRun Form
+        form.fields["_job_queue"].initial = job_model.default_job_queue.pk
 
         if cls.supports_dryrun and (not initial or "dryrun" not in initial):
             # Set initial "dryrun" checkbox state based on the Meta parameter
@@ -503,6 +574,13 @@ class BaseJob:
             for _, field in form.fields.items():
                 field.disabled = True
 
+        # Ensure non-Job-specific fields are still last after applying field_order
+        for field in ["_job_queue", "_profile", "_ignore_singleton_lock"]:
+            if field not in form.fields:
+                continue
+            value = form.fields.pop(field)
+            form.fields[field] = value
+
         return form
 
     @functools.cached_property
@@ -721,7 +799,7 @@ class BaseJob:
         """
         if isinstance(content, str):
             content = content.encode("utf-8")
-        max_size = get_settings_or_config("JOB_CREATE_FILE_MAX_SIZE")
+        max_size = get_settings_or_config("JOB_CREATE_FILE_MAX_SIZE", fallback=10 << 20)
         actual_size = len(content)
         if actual_size > max_size:
             raise ValueError(f"Provided {actual_size} bytes of content, but JOB_CREATE_FILE_MAX_SIZE is {max_size}")
@@ -1133,16 +1211,32 @@ def run_job(self, job_class_path, *args, **kwargs):
         raise KeyError(f"Job class not found for class path {job_class_path}")
     job = job_class()
     job.request = self.request
+    job_result = JobResult.objects.get(id=self.request.id)
+    payload = {
+        "job_result_id": self.request.id,
+        "job_name": job.name,
+        "user_name": job_result.user.username,
+    }
+    if not job.job_model.has_sensitive_variables:
+        payload["job_kwargs"] = kwargs
     try:
+        publish_event(topic="nautobot.jobs.job.started", payload=payload)
         job.before_start(self.request.id, args, kwargs)
         result = job(*args, **kwargs)
         job.on_success(result, self.request.id, args, kwargs)
         job.after_return(JobResultStatusChoices.STATUS_SUCCESS, result, self.request.id, args, kwargs, None)
+        payload["job_output"] = result
+        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         return result
     except Exception as exc:
         einfo = ExceptionInfo(sys.exc_info())
         job.on_failure(exc, self.request.id, args, kwargs, einfo)
         job.after_return(JobResultStatusChoices.STATUS_FAILURE, exc, self.request.id, args, kwargs, einfo)
+        payload["einfo"] = {
+            "exc_type": type(exc).__name__,
+            "exc_message": sanitize(str(exc)),
+        }
+        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         raise
 
 

nautobot/extras/management/__init__.py

@@ -28,6 +28,7 @@ STATUS_CHOICESET_MAP = {
     "dcim.InterfaceRedundancyGroup": dcim_choices.InterfaceRedundancyGroupStatusChoices,
     "dcim.SoftwareImageFile": dcim_choices.SoftwareImageFileStatusChoices,
     "dcim.SoftwareVersion": dcim_choices.SoftwareVersionStatusChoices,
+    "dcim.VirtualDeviceContext": dcim_choices.VirtualDeviceContextStatusChoices,
     "extras.ContactAssociation": extras_choices.ContactAssociationStatusChoices,
     "ipam.IPAddress": ipam_choices.IPAddressStatusChoices,
     "ipam.Prefix": ipam_choices.PrefixStatusChoices,

nautobot/extras/management/commands/runjob.py

@@ -1,14 +1,11 @@
-import json
 import time
 
 from django.contrib.auth import get_user_model
 from django.core.management.base import BaseCommand, CommandError
-from django.utils import timezone
 
-from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
-from nautobot.extras.jobs import get_job
-from nautobot.extras.models import Job, JobLogEntry, JobResult
-from nautobot.extras.utils import get_worker_count
+from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.extras.management.utils import report_job_status, validate_job_and_job_data
+from nautobot.extras.models import Job, JobResult
 
 
 class Command(BaseCommand):
@@ -38,42 +35,15 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         if "." not in options["job"]:
             raise CommandError('Job must be specified in the Python module form: "<module_name>.<JobClassName>"')
-        job_class = get_job(options["job"])
-        if not job_class:
-            raise CommandError(f'Job "{options["job"]}" not found')
-
         User = get_user_model()
         try:
             user = User.objects.get(username=options["username"])
         except User.DoesNotExist as exc:
             raise CommandError("No such user") from exc
 
-        data = {}
-        try:
-            if options.get("data"):
-                data = json.loads(options["data"])
-        except json.decoder.JSONDecodeError as error:
-            raise CommandError(f"Invalid JSON data:\n{error!s}") from error
-
-        try:
-            job_model = Job.objects.get_for_class_path(options["job"])
-        except Job.DoesNotExist as error:
-            raise CommandError(f"Job {options['job']} does not exist.") from error
-
-        try:
-            job_model = Job.objects.restrict(user, "run").get_for_class_path(options["job"])
-        except Job.DoesNotExist:
-            raise CommandError(f"User {options['username']} does not have permission to run this Job") from None
-
-        if not job_model.installed or job_model.job_class is None:
-            raise CommandError("Job is not presently installed")
-        if not job_model.enabled:
-            raise CommandError("Job is not presently enabled to be run")
-        if not options["local"] and not get_worker_count():
-            raise CommandError("No Celery worker detected. Perhaps you meant to specify --local?")
-
-        # Run the job and create a new JobResult
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {options['job']}...")
+        job_class_path = options["job"]
+        data = validate_job_and_job_data(self, user, job_class_path, options.get("data"))
+        job_model = Job.objects.get_for_class_path(job_class_path)
 
         if options["local"]:
             job_result = JobResult.execute_job(job_model, user, profile=options["profile"], **data)
@@ -86,46 +56,4 @@ class Command(BaseCommand):
                 job_result.refresh_from_db()
 
         # Report on success/failure
-        groups = set(JobLogEntry.objects.filter(job_result=job_result).values_list("grouping", flat=True))
-        for group in sorted(groups):
-            logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
-            debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
-            info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
-            warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
-            error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
-            critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
-
-            self.stdout.write(
-                f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
-            )
-
-            for log_entry in logs:
-                status = log_entry.log_level
-                if status == "success":
-                    status = self.style.SUCCESS(status)
-                elif status == "info":
-                    status = status
-                elif status == "warning":
-                    status = self.style.WARNING(status)
-                elif status == "failure":
-                    status = self.style.NOTICE(status)
-
-                if log_entry.log_object:
-                    self.stdout.write(f"\t\t{status}: {log_entry.log_object}: {log_entry.message}")
-                else:
-                    self.stdout.write(f"\t\t{status}: {log_entry.message}")
-
-        if job_result.result:
-            self.stdout.write(str(job_result.result))
-
-        if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
-            status = self.style.ERROR("FAILURE")
-        elif job_result.status == JobResultStatusChoices.STATUS_SUCCESS:
-            status = self.style.SUCCESS("SUCCESS")
-        else:
-            status = self.style.WARNING(job_result.status)
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: {status}")
-
-        # Wrap things up
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: Duration {job_result.duration}")
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Finished")
+        report_job_status(self, job_result)

nautobot/extras/management/commands/runjob_with_job_result.py

@@ -0,0 +1,46 @@
+from django.core.management.base import BaseCommand, CommandError
+
+from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.extras.management.utils import report_job_status, validate_job_and_job_data
+from nautobot.extras.models import JobResult
+
+
+class Command(BaseCommand):
+    help = "Run a job (script, report) to validate or update data in Nautobot"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "job_result",
+            help="Pass in an existing job result id from the database to continue executing the job on a local system",
+        )
+        parser.add_argument(
+            "--profile",
+            action="store_true",
+            help="Run cProfile on the job execution and write the result to the disk under /tmp.",
+        )
+
+    def handle(self, *args, **options):
+        job_result = None
+        job_result_id = options["job_result"]
+        try:
+            job_result = JobResult.objects.get(pk=job_result_id)
+        except JobResult.DoesNotExist:
+            raise CommandError(f"Job result with pk {job_result_id} not found.")
+        if job_result.status != JobResultStatusChoices.STATUS_PENDING:
+            raise CommandError(
+                f"Job result has an invalid status {job_result.status} for this command."
+                f" You can only pass in a job result with status {JobResultStatusChoices.STATUS_PENDING}"
+            )
+
+        job_user = job_result.user
+        job_model = job_result.job_model
+        job_class_path = job_model.class_path
+
+        data = validate_job_and_job_data(self, job_user, job_class_path, job_result.task_kwargs)
+
+        # execute_job here implies "--local"
+        job_result = JobResult.execute_job(
+            job_model, job_user, profile=options["profile"], job_result=job_result, **data
+        )
+        # Report on success/failure
+        report_job_status(self, job_result)

nautobot/extras/management/utils.py

@@ -0,0 +1,87 @@
+import json
+
+from django.core.management.base import CommandError
+from django.utils import timezone
+
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.jobs import get_job
+from nautobot.extras.models import Job, JobLogEntry
+
+
+def validate_job_and_job_data(command, user, job_class_path, data=None):
+    job_data = {}
+    try:
+        if data:
+            job_data = json.loads(data)
+    except json.decoder.JSONDecodeError as error:
+        raise CommandError(f"Invalid JSON data:\n{error!s}") from error
+
+    if not get_job(job_class_path, reload=True):
+        raise CommandError(f'Job "{job_class_path}" not found')
+
+    try:
+        job_model = Job.objects.get_for_class_path(job_class_path)
+    except Job.DoesNotExist as error:
+        raise CommandError(f"Job {job_class_path} does not exist.") from error
+
+    try:
+        job_model = Job.objects.restrict(user, "run").get_for_class_path(job_class_path)
+    except Job.DoesNotExist:
+        raise CommandError(f"User {user.username} does not have permission to run this Job") from None
+
+    if not job_model.installed or job_model.job_class is None:
+        raise CommandError("Job is not presently installed")
+    if not job_model.enabled:
+        raise CommandError("Job is not presently enabled to be run")
+
+    # Run the job and create a new JobResult
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {job_class_path}...")
+    return job_data
+
+
+def report_job_status(command, job_result):
+    # Report on success/failure
+    job_class_path = job_result.job_model.class_path
+    groups = set(JobLogEntry.objects.filter(job_result=job_result).values_list("grouping", flat=True))
+    for group in sorted(groups):
+        logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
+        debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
+        info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
+        warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
+        error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
+        critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
+
+        command.stdout.write(
+            f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
+        )
+
+        for log_entry in logs:
+            status = log_entry.log_level
+            if status == "success":
+                status = command.style.SUCCESS(status)
+            elif status == "info":
+                status = status
+            elif status == "warning":
+                status = command.style.WARNING(status)
+            elif status == "failure":
+                status = command.style.NOTICE(status)
+
+            if log_entry.log_object:
+                command.stdout.write(f"\t\t{status}: {log_entry.log_object}: {log_entry.message}")
+            else:
+                command.stdout.write(f"\t\t{status}: {log_entry.message}")
+
+    if job_result.result:
+        command.stdout.write(str(job_result.result))
+
+    if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
+        status = command.style.ERROR("FAILURE")
+    elif job_result.status == JobResultStatusChoices.STATUS_SUCCESS:
+        status = command.style.SUCCESS("SUCCESS")
+    else:
+        status = command.style.WARNING(job_result.status)
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class_path}: {status}")
+
+    # Wrap things up
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class_path}: Duration {job_result.duration}")
+    command.stdout.write(f"[{timezone.now():%H:%M:%S}] Finished")

nautobot/extras/migrations/0117_create_job_queue_model.py

@@ -0,0 +1,129 @@
+# Generated by Django 4.2.15 on 2024-08-13 20:36
+
+import uuid
+
+import django.core.serializers.json
+from django.db import migrations, models
+import django.db.models.deletion
+
+import nautobot.core.models.fields
+import nautobot.extras.models.mixins
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("tenancy", "0009_update_all_charfields_max_length_to_255"),
+        ("extras", "0116_fix_dynamic_group_group_type_data_migration"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="JobQueue",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True
+                    ),
+                ),
+                ("created", models.DateTimeField(auto_now_add=True, null=True)),
+                ("last_updated", models.DateTimeField(auto_now=True, null=True)),
+                (
+                    "_custom_field_data",
+                    models.JSONField(blank=True, default=dict, encoder=django.core.serializers.json.DjangoJSONEncoder),
+                ),
+                ("name", models.CharField(max_length=255, unique=True)),
+                ("description", models.CharField(blank=True, max_length=255)),
+                ("queue_type", models.CharField(max_length=50)),
+                ("tags", nautobot.core.models.fields.TagsField(through="extras.TaggedItem", to="extras.Tag")),
+                (
+                    "tenant",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="job_queues",
+                        to="tenancy.tenant",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["name"],
+            },
+            bases=(
+                nautobot.extras.models.mixins.DynamicGroupMixin,
+                nautobot.extras.models.mixins.NotesMixin,
+                models.Model,
+            ),
+        ),
+        migrations.CreateModel(
+            name="JobQueueAssignment",
+            fields=[
+                (
+                    "id",
+                    models.UUIDField(
+                        default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True
+                    ),
+                ),
+                (
+                    "job",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="job_queue_assignments",
+                        to="extras.job",
+                    ),
+                ),
+                (
+                    "job_queue",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="job_assignments",
+                        to="extras.jobqueue",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["job", "job_queue"],
+                "unique_together": {("job", "job_queue")},
+            },
+        ),
+        migrations.AddField(
+            model_name="job",
+            name="job_queues",
+            field=models.ManyToManyField(
+                through="extras.JobQueueAssignment", to="extras.jobqueue", related_name="jobs"
+            ),
+        ),
+        migrations.AddField(
+            model_name="job",
+            name="default_job_queue_override",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="job",
+            name="default_job_queue",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                to="extras.jobqueue",
+                related_name="default_for_jobs",
+            ),
+        ),
+        migrations.RenameField(
+            model_name="job",
+            old_name="task_queues_override",
+            new_name="job_queues_override",
+        ),
+        migrations.AddField(
+            model_name="scheduledjob",
+            name="job_queue",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="scheduled_jobs",
+                to="extras.jobqueue",
+            ),
+        ),
+    ]