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

nautobot/extras/jobs.py

@@ -30,25 +30,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,
@@ -98,15 +105,13 @@ class BaseJob:
 
         - name (str)
         - description (str)
-        - approval_required (bool)
-        - dryrun_default (bool)
-        - field_order (list)
-        - has_sensitive_variables (bool)
         - hidden (bool)
+        - field_order (list)
+        - approval_required (bool)
         - soft_time_limit (int)
-        - task_queues (list)
-        - template_name (str)
         - time_limit (int)
+        - has_sensitive_variables (bool)
+        - task_queues (list)
         """
 
     def __init__(self):
@@ -275,7 +280,7 @@ 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"})
 
     @final
     @classproperty
@@ -295,7 +300,7 @@ class BaseJob:
         - my_plugin.jobs.MyPluginJob - App-provided Job
         - git_repository.jobs.myjob.MyJob - GitRepository Job
         """
-        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
+        return f"{cls.__module__}.{cls.__name__}"
 
     @final
     @classproperty
@@ -332,7 +337,7 @@ class BaseJob:
     @final
     @classproperty
     def name(cls) -> str:  # pylint: disable=no-self-argument
-        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)  # pylint: disable=no-member
+        return cls._get_meta_attr_and_assert_type("name", cls.__name__, expected_type=str)
 
     @final
     @classproperty
@@ -420,7 +425,7 @@ class BaseJob:
     @classproperty
     def registered_name(cls) -> str:  # pylint: disable=no-self-argument
         """Deprecated - use class_path classproperty instead."""
-        return f"{cls.__module__}.{cls.__name__}"  # pylint: disable=no-member
+        return f"{cls.__module__}.{cls.__name__}"
 
     @classmethod
     def _get_vars(cls):
@@ -475,18 +480,28 @@ 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/",
+        )
 
-        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
-        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
-
-        # 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 +518,11 @@ 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"]:
+            value = form.fields.pop(field)
+            form.fields[field] = value
+
         return form
 
     @functools.cached_property
@@ -721,7 +741,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}")
@@ -1011,7 +1031,7 @@ class JobHookReceiver(Job):
 
     object_change = ObjectVar(model=ObjectChange)
 
-    def run(self, object_change):  # pylint: disable=arguments-differ
+    def run(self, object_change):
         """JobHookReceiver subclasses generally shouldn't need to override this method."""
         self.receive_job_hook(
             change=object_change,
@@ -1040,7 +1060,7 @@ class JobButtonReceiver(Job):
     object_pk = StringVar()
     object_model_name = StringVar()
 
-    def run(self, object_pk, object_model_name):  # pylint: disable=arguments-differ
+    def run(self, object_pk, object_model_name):
         """JobButtonReceiver subclasses generally shouldn't need to override this method."""
         model = get_model_from_name(object_model_name)
         obj = model.objects.get(pk=object_pk)
@@ -1133,16 +1153,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/managers.py

@@ -22,9 +22,8 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
             return self.model(id=task_id)
 
     @transaction_retry(max_retries=2)
-    def store_result(  # pylint:disable=arguments-differ  # Nautobot adds kwargs like job_model_id and scheduled_job_id
+    def store_result(
         self,
-        *,
         task_id,
         result,
         status,
@@ -42,7 +41,6 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         using=None,
         content_type=None,
         content_encoding=None,
-        **kwargs,
     ):
         """
         Store the result and status of a Celery task.

nautobot/extras/migrations/0018_joblog_data_migration.py

@@ -2,6 +2,7 @@ from collections import OrderedDict
 
 from django.db import migrations
 
+from nautobot.extras.choices import LogLevelChoices
 from nautobot.extras.constants import (
     JOB_LOG_MAX_ABSOLUTE_URL_LENGTH,
     JOB_LOG_MAX_GROUPING_LENGTH,
@@ -122,13 +123,14 @@ def reverse_migrate_params(apps, schema_editor):
                 ]
             )
 
-            job_result.data[entry.grouping].setdefault(entry.log_level, 0)
-            job_result.data[entry.grouping][entry.log_level] += 1
-            if "total" not in job_result.data:
-                job_result.data["total"] = _data_grouping_struct()
-                del job_result.data["total"]["log"]
-            job_result.data["total"].setdefault(entry.log_level, 0)
-            job_result.data["total"][entry.log_level] += 1
+            if entry.log_level != LogLevelChoices.LOG_DEFAULT:
+                job_result.data[entry.grouping].setdefault(entry.log_level, 0)
+                job_result.data[entry.grouping][entry.log_level] += 1
+                if "total" not in job_result.data:
+                    job_result.data["total"] = _data_grouping_struct()
+                    del job_result.data["total"]["log"]
+                job_result.data["total"].setdefault(entry.log_level, 0)
+                job_result.data["total"][entry.log_level] += 1
 
             job_result.save()
 

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",
+            ),
+        ),
+    ]