dj-queue 0.9.2__tar.gz → 0.10.1__tar.gz

{dj_queue-0.9.2 → dj_queue-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.9.2
+Version: 0.10.1
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -713,9 +713,12 @@ from django.core.asgi import get_asgi_application
 from dj_queue.contrib.asgi import DjQueueLifespan
 
 django_application = get_asgi_application()
-application = DjQueueLifespan(django_application)
+application = DjQueueLifespan(django_application, forward_wrapped_lifespan=False)
 ```
 
+Set `forward_wrapped_lifespan=False` when the wrapped app does not implement the
+ASGI lifespan protocol itself, such as Django's plain `get_asgi_application()`.
+
 ### Gunicorn
 
 Import the provided hooks in your Gunicorn config:

{dj_queue-0.9.2 → dj_queue-0.10.1}/README.md

@@ -687,9 +687,12 @@ from django.core.asgi import get_asgi_application
 from dj_queue.contrib.asgi import DjQueueLifespan
 
 django_application = get_asgi_application()
-application = DjQueueLifespan(django_application)
+application = DjQueueLifespan(django_application, forward_wrapped_lifespan=False)
 ```
 
+Set `forward_wrapped_lifespan=False` when the wrapped app does not implement the
+ASGI lifespan protocol itself, such as Django's plain `get_asgi_application()`.
+
 ### Gunicorn
 
 Import the provided hooks in your Gunicorn config:

{dj_queue-0.9.2 → dj_queue-0.10.1}/dj_queue/admin.py

@@ -389,8 +389,10 @@ class JobConcurrencyKeyListFilter(admin.SimpleListFilter):
 
   def lookups(self, request, model_admin):
     alias = model_admin._backend_database_alias(request)
+    backend_alias = model_admin._backend_alias(request)
     return tuple(
       Job.objects.using(alias)
+      .filter(backend_alias=backend_alias)
       .exclude(concurrency_key__isnull=True)
       .exclude(concurrency_key="")
       .order_by("concurrency_key")
@@ -713,6 +715,7 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
 @admin.register(Process)
 class ProcessAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
+  backend_filter_field = "backend_alias"
   list_display = (
     "name",
     "backend_alias",

{dj_queue-0.9.2 → dj_queue-0.10.1}/dj_queue/api.py

@@ -1,9 +1,12 @@
+from datetime import timedelta
 from functools import partial
 
 from django.db.models.functions import Coalesce
 from django.db import transaction
 from django.utils import timezone
 
+from dj_queue import observability
+from dj_queue.config import load_backend_config
 from dj_queue.db import get_database_alias
 from dj_queue.models import Pause, ReadyExecution
 from dj_queue.operations.jobs import (
@@ -50,6 +53,9 @@ class QueueInfo:
 
   @property
   def latency(self):
+    if self.paused:
+      return None
+
     oldest = (
       self._ready_queryset()
       .annotate(latency_at=Coalesce("latency_started_at", "created_at"))
@@ -59,7 +65,7 @@ class QueueInfo:
     )
     if oldest is None:
       return 0.0
-    return (timezone.now() - oldest).total_seconds()
+    return max((timezone.now() - oldest).total_seconds(), 0.0)
 
   @property
   def paused(self):
@@ -93,18 +99,15 @@ class QueueInfo:
 
   @classmethod
   def all(cls, *, backend_alias="default"):
-    alias = get_database_alias(backend_alias)
-    queue_names = (
-      ReadyExecution.objects.using(alias)
-      .filter(backend_alias=backend_alias)
-      .order_by("queue_name")
-      .values_list(
-        "queue_name",
-        flat=True,
-      )
-      .distinct()
+    now = timezone.now()
+    config = load_backend_config(backend_alias)
+    process_cutoff = now - timedelta(seconds=config.process_alive_threshold)
+    queue_rows = observability.queue_rows(
+      backend_alias=backend_alias,
+      now=now,
+      process_cutoff=process_cutoff,
     )
-    return [cls(queue_name, backend_alias=backend_alias) for queue_name in queue_names]
+    return [cls(row["name"], backend_alias=backend_alias) for row in queue_rows]
 
   def _ready_queryset(self):
     alias = get_database_alias(self.backend_alias)

{dj_queue-0.9.2 → dj_queue-0.10.1}/dj_queue/backend.py

@@ -9,6 +9,7 @@ from dj_queue.operations.jobs import (
   DispatchOutcome,
   enqueue_job_with_dispatch,
   enqueue_jobs_bulk,
+  validate_priority,
   validate_queue_allowed,
 )
 from dj_queue.task_results import task_result_from_enqueued_job, task_result_from_job
@@ -22,6 +23,7 @@ class DjQueueBackend(BaseTaskBackend):
 
   def validate_task(self, task):
     validate_queue_allowed(task.queue_name, backend_alias=self.alias)
+    validate_priority(task.priority)
     return super().validate_task(task)
 
   def enqueue(self, task, args, kwargs):

{dj_queue-0.9.2 → dj_queue-0.10.1}/dj_queue/config.py

@@ -5,7 +5,6 @@ import tomllib
 import warnings
 from collections.abc import Mapping, Sequence
 from dataclasses import asdict, dataclass, field, replace
-from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
@@ -61,6 +60,7 @@ DJ_QUEUE_BACKEND_PATH = "dj_queue.backend.DjQueueBackend"
 TRUTHY_ENV_VALUES = {"1", "true", "yes", "on"}
 FALSY_ENV_VALUES = {"0", "false", "no", "off"}
 CONFIG_ENV_KEYS = ("DJ_QUEUE_CONFIG", "DJ_QUEUE_MODE", "DJ_QUEUE_SKIP_RECURRING")
+_BACKEND_CONFIG_CACHE = {}
 
 
 @dataclass(frozen=True, slots=True)
@@ -149,24 +149,41 @@ def load_backend_config(
   if tasks_settings is None:
     tasks_settings = getattr(settings, "TASKS", {})
 
-  return _load_backend_config_cached(
+  env_values = {key: env.get(key) for key in CONFIG_ENV_KEYS if env.get(key) is not None}
+  cache_key = (
     backend_alias,
     _cache_key(cli_overrides),
-    _cache_key({key: env.get(key) for key in CONFIG_ENV_KEYS if env.get(key) is not None}),
+    _cache_key(env_values),
     _cache_key(tasks_settings),
   )
+  if cache_key not in _BACKEND_CONFIG_CACHE:
+    _BACKEND_CONFIG_CACHE[cache_key] = _load_backend_config_uncached(
+      backend_alias,
+      cli_overrides,
+      env_values,
+      tasks_settings,
+    )
+  return _BACKEND_CONFIG_CACHE[cache_key]
+
+
+def load_allowed_queues(
+  backend_alias: str = "default",
+  *,
+  tasks_settings: Mapping[str, Any] | None = None,
+) -> tuple[str, ...]:
+  if tasks_settings is None:
+    tasks_settings = getattr(settings, "TASKS", {})
+  ensure_dj_queue_backend_alias(tasks_settings, backend_alias)
+  backend_block = _backend_block(tasks_settings, backend_alias)
+  return _as_string_tuple(backend_block.get("QUEUES", []))
 
 
-@lru_cache(maxsize=None)
-def _load_backend_config_cached(
+def _load_backend_config_uncached(
   backend_alias: str,
-  cli_overrides_key: str,
-  env_key: str,
-  tasks_settings_key: str,
+  cli_overrides: Mapping[str, Any],
+  env: Mapping[str, str],
+  tasks_settings: Mapping[str, Any],
 ) -> BackendConfig:
-  cli_overrides = json.loads(cli_overrides_key)
-  env = json.loads(env_key)
-  tasks_settings = json.loads(tasks_settings_key)
   ensure_dj_queue_backend_alias(tasks_settings, backend_alias)
   backend_block = _backend_block(tasks_settings, backend_alias)
   resolved_options = _resolved_options(backend_alias, backend_block, cli_overrides, env)
@@ -184,8 +201,13 @@ def _load_backend_config_cached(
   preserve_finished_jobs = _bool_option(
     resolved_options["preserve_finished_jobs"], "preserve_finished_jobs"
   )
+  allowed_queues = _as_string_tuple(backend_block.get("QUEUES", []))
   on_thread_error = _validated_callback_path(resolved_options.get("on_thread_error"))
-  recurring = _build_recurring_config(resolved_options.get("recurring", {}))
+  recurring = _build_recurring_config(
+    resolved_options.get("recurring", {}),
+    allowed_queues=allowed_queues,
+    backend_alias=backend_alias,
+  )
   scheduler = _build_scheduler_config(resolved_options.get("scheduler", DEFAULT_SCHEDULER))
   workers = _build_worker_configs(resolved_options.get("workers", []), mode)
   dispatchers = _build_dispatcher_configs(resolved_options.get("dispatchers", []))
@@ -213,7 +235,7 @@ def _load_backend_config_cached(
 
   return BackendConfig(
     backend_alias=backend_alias,
-    allowed_queues=_as_string_tuple(backend_block.get("QUEUES", [])),
+    allowed_queues=allowed_queues,
     mode=mode,
     workers=workers,
     dispatchers=dispatchers,
@@ -228,10 +250,15 @@ def _load_backend_config_cached(
     shutdown_timeout=_nonnegative_float(resolved_options["shutdown_timeout"], "shutdown_timeout"),
     supervisor_pidfile=resolved_options["supervisor_pidfile"],
     preserve_finished_jobs=preserve_finished_jobs,
-    clear_finished_jobs_after=_optional_int(resolved_options["clear_finished_jobs_after"]),
-    clear_failed_jobs_after=_optional_int(resolved_options["clear_failed_jobs_after"]),
-    clear_recurring_executions_after=_optional_int(
-      resolved_options["clear_recurring_executions_after"]
+    clear_finished_jobs_after=_optional_nonnegative_int(
+      resolved_options["clear_finished_jobs_after"], "clear_finished_jobs_after"
+    ),
+    clear_failed_jobs_after=_optional_nonnegative_int(
+      resolved_options["clear_failed_jobs_after"], "clear_failed_jobs_after"
+    ),
+    clear_recurring_executions_after=_optional_nonnegative_int(
+      resolved_options["clear_recurring_executions_after"],
+      "clear_recurring_executions_after",
     ),
     default_concurrency_duration=_positive_int(
       resolved_options["default_concurrency_duration"],
@@ -506,7 +533,12 @@ def _build_scheduler_config(raw_scheduler: Any) -> SchedulerConfig:
   )
 
 
-def _build_recurring_config(raw_recurring: Any) -> dict[str, RecurringTaskConfig]:
+def _build_recurring_config(
+  raw_recurring: Any,
+  *,
+  allowed_queues: tuple[str, ...],
+  backend_alias: str,
+) -> dict[str, RecurringTaskConfig]:
   if raw_recurring is None:
     return {}
   if not isinstance(raw_recurring, Mapping):
@@ -524,14 +556,29 @@ def _build_recurring_config(raw_recurring: Any) -> dict[str, RecurringTaskConfig
     if not is_valid_cron(str(schedule)):
       raise ImproperlyConfigured(f"recurring task {key!r} has an invalid cron schedule")
 
+    queue_name = str(raw_entry.get("queue_name", "default"))
+    priority = _priority_int(raw_entry.get("priority", 0), f"recurring task {key!r} priority")
+    if allowed_queues and queue_name not in allowed_queues:
+      raise ImproperlyConfigured(
+        f"recurring task {key!r} is invalid: queue {queue_name!r} is not allowed for backend {backend_alias!r}"
+      )
+    try:
+      task = import_string(str(task_path))
+    except ImportError as exc:
+      raise ImproperlyConfigured(f"recurring task {key!r} is invalid: {exc}") from exc
+    if not hasattr(task, "using"):
+      raise ImproperlyConfigured(
+        f"recurring task {key!r} is invalid: task_path must reference a Django task"
+      )
+
     recurring[str(key)] = RecurringTaskConfig(
       key=str(key),
       task_path=str(task_path),
       schedule=str(schedule),
       args=tuple(raw_entry.get("args", [])),
       kwargs=dict(raw_entry.get("kwargs", {})),
-      queue_name=str(raw_entry.get("queue_name", "default")),
-      priority=int(raw_entry.get("priority", 0)),
+      queue_name=queue_name,
+      priority=priority,
       description=str(raw_entry.get("description", "")),
     )
   return recurring
@@ -570,13 +617,20 @@ def _as_string_tuple(value: Any) -> tuple[str, ...]:
   return tuple(str(item) for item in value)
 
 
-def _optional_int(value: Any) -> int | None:
+def _optional_nonnegative_int(value: Any, setting_name: str) -> int | None:
   if value is None:
     return None
-  return int(value)
+  number = _integer(value, setting_name, "a non-negative integer")
+  if number < 0:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a non-negative integer, got {value!r}"
+    )
+  return number
 
 
 def _positive_float(value: Any, setting_name: str) -> float:
+  if isinstance(value, bool):
+    raise ImproperlyConfigured(f"dj_queue {setting_name} must be a positive number, got {value!r}")
   try:
     number = float(value)
   except (TypeError, ValueError) as exc:
@@ -590,6 +644,10 @@ def _positive_float(value: Any, setting_name: str) -> float:
 
 
 def _nonnegative_float(value: Any, setting_name: str) -> float:
+  if isinstance(value, bool):
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a non-negative number, got {value!r}"
+    )
   try:
     number = float(value)
   except (TypeError, ValueError) as exc:
@@ -605,12 +663,7 @@ def _nonnegative_float(value: Any, setting_name: str) -> float:
 
 
 def _positive_int(value: Any, setting_name: str) -> int:
-  try:
-    number = int(value)
-  except (TypeError, ValueError, OverflowError) as exc:
-    raise ImproperlyConfigured(
-      f"dj_queue {setting_name} must be a positive integer, got {value!r}"
-    ) from exc
+  number = _integer(value, setting_name, "a positive integer")
 
   if number <= 0:
     raise ImproperlyConfigured(
@@ -619,5 +672,31 @@ def _positive_int(value: Any, setting_name: str) -> int:
   return number
 
 
+def _priority_int(value: Any, setting_name: str) -> int:
+  number = _integer(value, setting_name, "an integer from -100 to 100")
+
+  if number < -100 or number > 100:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be an integer from -100 to 100, got {value!r}"
+    )
+  return number
+
+
+def _integer(value: Any, setting_name: str, expectation: str) -> int:
+  if isinstance(value, bool):
+    raise ImproperlyConfigured(f"dj_queue {setting_name} must be {expectation}, got {value!r}")
+  if isinstance(value, int):
+    return value
+  if isinstance(value, str):
+    normalized = value.strip()
+    unsigned = normalized[1:] if normalized[:1] in {"+", "-"} else normalized
+    if unsigned.isdecimal():
+      return int(normalized)
+  raise ImproperlyConfigured(f"dj_queue {setting_name} must be {expectation}, got {value!r}")
+
+
 def _cache_key(value: Any) -> str:
-  return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
+  try:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"))
+  except (TypeError, ValueError) as exc:
+    raise ImproperlyConfigured("dj_queue config values must be JSON-serializable") from exc

dj_queue-0.10.1/dj_queue/contrib/asgi.py

@@ -0,0 +1,148 @@
+import asyncio
+import inspect
+from contextlib import suppress
+
+from dj_queue.runtime.errors import handle_thread_error
+from dj_queue.runtime.supervisor import AsyncSupervisor
+
+
+def build_supervisor(backend_alias="default"):
+  return AsyncSupervisor.from_backend_config(backend_alias=backend_alias, standalone=False)
+
+
+class DjQueueLifespan:
+  def __init__(self, app, *, backend_alias="default", forward_wrapped_lifespan=True):
+    self.app = app
+    self.backend_alias = backend_alias
+    self.forward_wrapped_lifespan = forward_wrapped_lifespan
+    self.supervisor = None
+    self._poll_task = None
+    self._poll_stop = None
+
+  async def _poll_supervisor(self):
+    while (
+      self.supervisor is not None and self._poll_stop is not None and not self._poll_stop.is_set()
+    ):
+      try:
+        await asyncio.to_thread(self.supervisor.poll_once)
+      except Exception as error:
+        handle_thread_error(
+          error,
+          context="supervisor.run",
+          backend_alias=self.supervisor.backend_alias,
+        )
+
+      if self.supervisor is None or self._poll_stop is None or self._poll_stop.is_set():
+        return
+
+      try:
+        await asyncio.wait_for(self._poll_stop.wait(), timeout=self.supervisor.polling_interval)
+      except asyncio.TimeoutError:
+        continue
+
+  async def _start_wrapped_lifespan_app(self, scope, receive, send):
+    result = self.app(scope, receive, send)
+    if inspect.isawaitable(result):
+      return asyncio.create_task(result)
+
+    loop = asyncio.get_running_loop()
+    task = loop.create_future()
+    task.set_result(result)
+    return task
+
+  async def _forward_lifespan_message(self, app_task, receive_queue, send_queue, message):
+    if app_task.done():
+      await app_task
+      return None
+
+    await receive_queue.put(message)
+    response_task = asyncio.create_task(send_queue.get())
+    try:
+      done, _ = await asyncio.wait({app_task, response_task}, return_when=asyncio.FIRST_COMPLETED)
+      if response_task in done:
+        return response_task.result()
+      await app_task
+      return None
+    finally:
+      if not response_task.done():
+        response_task.cancel()
+        with suppress(asyncio.CancelledError):
+          await response_task
+
+  async def _start_supervisor(self):
+    self.supervisor = build_supervisor(self.backend_alias)
+    await asyncio.to_thread(self.supervisor.start)
+    self._poll_stop = asyncio.Event()
+    self._poll_task = asyncio.create_task(self._poll_supervisor())
+
+  @staticmethod
+  def _is_unsupported_lifespan_error(error):
+    message = str(error).lower()
+    return isinstance(error, ValueError) and (
+      "django can only handle asgi/http connections" in message and "lifespan" in message
+    )
+
+  async def _stop_supervisor(self):
+    poll_stop = self._poll_stop
+    self._poll_stop = None
+    if poll_stop is not None:
+      poll_stop.set()
+
+    poll_task = self._poll_task
+    self._poll_task = None
+    if poll_task is not None:
+      await poll_task
+
+    if self.supervisor is not None:
+      await asyncio.to_thread(self.supervisor.stop)
+      self.supervisor = None
+
+  async def __call__(self, scope, receive, send):
+    if scope["type"] != "lifespan":
+      await self.app(scope, receive, send)
+      return
+
+    receive_queue = asyncio.Queue()
+    send_queue = asyncio.Queue()
+    app_task = await self._start_wrapped_lifespan_app(scope, receive_queue.get, send_queue.put)
+    wrapped_app_supports_lifespan = self.forward_wrapped_lifespan
+
+    try:
+      while True:
+        message = await receive()
+        if message["type"] == "lifespan.startup":
+          response = None
+          if wrapped_app_supports_lifespan:
+            try:
+              response = await self._forward_lifespan_message(
+                app_task, receive_queue, send_queue, message
+              )
+            except Exception as error:
+              if not self._is_unsupported_lifespan_error(error):
+                raise
+              wrapped_app_supports_lifespan = False
+          if response is not None and response["type"] != "lifespan.startup.complete":
+            await send(response)
+            return
+
+          await self._start_supervisor()
+          await send({"type": "lifespan.startup.complete"})
+        elif message["type"] == "lifespan.shutdown":
+          await self._stop_supervisor()
+          response = None
+          if wrapped_app_supports_lifespan:
+            response = await self._forward_lifespan_message(
+              app_task, receive_queue, send_queue, message
+            )
+          if response is None:
+            response = {"type": "lifespan.shutdown.complete"}
+          await send(response)
+          if wrapped_app_supports_lifespan:
+            await app_task
+          return
+    finally:
+      await self._stop_supervisor()
+      if not app_task.done():
+        app_task.cancel()
+        with suppress(asyncio.CancelledError):
+          await app_task

dj_queue-0.10.1/dj_queue/contrib/gunicorn.py

@@ -0,0 +1,154 @@
+import fcntl
+import tempfile
+import threading
+from pathlib import Path
+
+from dj_queue.runtime.errors import handle_thread_error
+from dj_queue.runtime.supervisor import AsyncSupervisor
+
+LOCK_PATH = Path(tempfile.gettempdir()) / "dj_queue_gunicorn_supervisor.lock"
+LOCK_RETRY_INTERVAL = 1.0
+
+
+def build_supervisor(backend_alias="default"):
+  return AsyncSupervisor.from_backend_config(backend_alias=backend_alias, standalone=False)
+
+
+def _set_supervisor_state(worker, **state):
+  for name, value in state.items():
+    setattr(worker, f"_dj_queue_{name}", value)
+
+
+def _start_embedded_supervisor(worker, *, backend_alias="default"):
+  lock_file = _try_acquire_supervisor_lock()
+  if lock_file is None:
+    return None
+
+  try:
+    supervisor = build_supervisor(backend_alias=backend_alias)
+    poll_stop = threading.Event()
+    _set_supervisor_state(
+      worker,
+      supervisor_lock=lock_file,
+      supervisor=supervisor,
+      supervisor_poll_stop=poll_stop,
+    )
+    supervisor.start()
+  except Exception:
+    _release_supervisor_lock(lock_file)
+    _set_supervisor_state(
+      worker,
+      supervisor_lock=None,
+      supervisor=None,
+      supervisor_poll_stop=None,
+      supervisor_poll_thread=None,
+    )
+    raise
+
+  def poll_supervisor():
+    stop_event = worker._dj_queue_supervisor_poll_stop
+    while stop_event.wait(supervisor.polling_interval) is False:
+      try:
+        supervisor.poll_once()
+      except Exception as error:
+        handle_thread_error(
+          error,
+          context="supervisor.run",
+          backend_alias=supervisor.backend_alias,
+        )
+
+  poll_thread = threading.Thread(target=poll_supervisor, daemon=True)
+  worker._dj_queue_supervisor_poll_thread = poll_thread
+  poll_thread.start()
+  return supervisor
+
+
+def _start_lock_retry_loop(worker, *, backend_alias="default"):
+  retry_stop = threading.Event()
+
+  def retry():
+    while retry_stop.wait(LOCK_RETRY_INTERVAL) is False:
+      if getattr(worker, "_dj_queue_supervisor", None) is not None:
+        return
+      if _start_embedded_supervisor(worker, backend_alias=backend_alias) is not None:
+        retry_stop.set()
+        return
+
+  retry_thread = threading.Thread(target=retry, daemon=True)
+  _set_supervisor_state(
+    worker, supervisor_retry_stop=retry_stop, supervisor_retry_thread=retry_thread
+  )
+  retry_thread.start()
+
+
+def post_fork(_server, worker):
+  _set_supervisor_state(
+    worker,
+    supervisor=None,
+    supervisor_lock=None,
+    supervisor_poll_stop=None,
+    supervisor_poll_thread=None,
+    supervisor_retry_stop=None,
+    supervisor_retry_thread=None,
+  )
+  supervisor = _start_embedded_supervisor(worker)
+  if supervisor is not None:
+    return supervisor
+
+  _start_lock_retry_loop(worker)
+  return None
+
+
+def worker_exit(_server, worker):
+  supervisor = getattr(worker, "_dj_queue_supervisor", None)
+  lock_file = getattr(worker, "_dj_queue_supervisor_lock", None)
+  stop_event = getattr(worker, "_dj_queue_supervisor_poll_stop", None)
+  poll_thread = getattr(worker, "_dj_queue_supervisor_poll_thread", None)
+  retry_stop = getattr(worker, "_dj_queue_supervisor_retry_stop", None)
+  retry_thread = getattr(worker, "_dj_queue_supervisor_retry_thread", None)
+
+  if retry_stop is not None:
+    retry_stop.set()
+  if retry_thread is not None:
+    retry_thread.join(timeout=1)
+    worker._dj_queue_supervisor_retry_thread = None
+  worker._dj_queue_supervisor_retry_stop = None
+
+  if stop_event is not None:
+    stop_event.set()
+  if poll_thread is not None:
+    poll_thread.join()
+    worker._dj_queue_supervisor_poll_thread = None
+  worker._dj_queue_supervisor_poll_stop = None
+  if supervisor is None:
+    if lock_file is not None:
+      _release_supervisor_lock(lock_file)
+      worker._dj_queue_supervisor_lock = None
+    return None
+
+  supervisor.stop()
+  worker._dj_queue_supervisor = None
+  _release_supervisor_lock(lock_file)
+  worker._dj_queue_supervisor_lock = None
+  return None
+
+
+def _try_acquire_supervisor_lock():
+  LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
+  lock_file = LOCK_PATH.open("a+")
+  try:
+    fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+  except BlockingIOError:
+    lock_file.close()
+    return None
+  return lock_file
+
+
+def _release_supervisor_lock(lock_file):
+  if lock_file is None:
+    return None
+  try:
+    fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+  finally:
+    lock_file.close()
+  return None