steady-queue 0.1.8__tar.gz → 0.2.1__tar.gz

{steady_queue-0.1.8/steady_queue.egg-info → steady_queue-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.1.8
+Version: 0.2.1
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -10,12 +10,15 @@ Project-URL: Documentation, https://steady-queue.readthedocs.io/en/latest/
 Project-URL: Tracker, https://github.com/knifecake/steady-queue/issues
 Project-URL: Releases, https://github.com/knifecake/steady-queue/releases
 Keywords: django,tasks,async,jobs,queues
+Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 6.0
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
 Classifier: Natural Language :: English
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -63,6 +66,7 @@ The database backend exposed by Steady Queue doesn't support the following optio
   result = task.return_value` will result in an error (even if the task has
   completed processing). Instead, we recommend saving the results directly on
   your database or file storage system if they need to be kept around.
+- **Requires a POSIX system** due to the concurrency model based on `os.fork`. Steady Queue doesn't run on windows.
 
 The Steady Queue backend advertises these limitations by [setting the
 corresponding flags][django-tasks-flags] on its backend.

{steady_queue-0.1.8 → steady_queue-0.2.1}/README.md

@@ -37,6 +37,7 @@ The database backend exposed by Steady Queue doesn't support the following optio
   result = task.return_value` will result in an error (even if the task has
   completed processing). Instead, we recommend saving the results directly on
   your database or file storage system if they need to be kept around.
+- **Requires a POSIX system** due to the concurrency model based on `os.fork`. Steady Queue doesn't run on windows.
 
 The Steady Queue backend advertises these limitations by [setting the
 corresponding flags][django-tasks-flags] on its backend.

{steady_queue-0.1.8 → steady_queue-0.2.1}/pyproject.toml

@@ -10,13 +10,17 @@ authors = [
 requires-python = ">=3.12"
 keywords = ["django", "tasks", "async", "jobs", "queues"]
 classifiers = [
+    "Development Status :: 4 - Beta",
     "Framework :: Django",
     "Framework :: Django :: 6.0",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
-    "Operating System :: OS Independent",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX",
+    "Operating System :: Unix",
     "Natural Language :: English",
+
 ]
 dependencies = [
     "crontab>=1.0.5",

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue/__init__.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
-VERSION = (0, 1, 8)
+VERSION = (0, 2, 1)
 
 __version__ = ".".join(map(str, VERSION))
 

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue/configuration.py

@@ -3,9 +3,11 @@ from datetime import timedelta
 from typing import Optional
 
 from crontab import CronTab
+from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.utils.module_loading import import_string
 
+from steady_queue.db_router import steady_queue_database_alias
 from steady_queue.processes.base import Base
 
 
@@ -167,6 +169,7 @@ class Configuration:
     def is_valid(self):
         self.errors = []
         self.errors.extend(self.validate_configured_processes())
+        self.errors.extend(self.validate_database_pool_size())
         self.errors.extend(self.validate_recurring_tasks())
 
         return len(self.errors) == 0
@@ -177,6 +180,39 @@ class Configuration:
 
         return []
 
+    def validate_database_pool_size(self) -> list[ValidationError]:
+        # Match Solid Queue behavior by validating worker thread count against
+        # the queue DB connection pool size when a max_size is explicitly set.
+        if len(self.options.workers) == 0:
+            return []
+
+        db_alias = steady_queue_database_alias()
+        db_config = settings.DATABASES.get(db_alias, {})
+
+        if db_config.get("ENGINE") != "django.db.backends.postgresql":
+            return []
+
+        pool_options = db_config.get("OPTIONS", {}).get("pool")
+        if not isinstance(pool_options, dict):
+            return []
+
+        pool_max_size = pool_options.get("max_size")
+        if not isinstance(pool_max_size, int):
+            return []
+
+        if pool_max_size < self.estimated_number_of_threads:
+            return [
+                ValidationError(
+                    "Steady Queue is configured to use "
+                    f"{self.estimated_number_of_threads} threads but the "
+                    f"database connection pool max_size for '{db_alias}' is "
+                    f"{pool_max_size}. Increase "
+                    f"DATABASES['{db_alias}']['OPTIONS']['pool']['max_size']."
+                )
+            ]
+
+        return []
+
     def validate_recurring_tasks(self) -> list[ValidationError]:
         if self.skip_recurring:
             return []
@@ -195,6 +231,13 @@ class Configuration:
 
         return errors
 
+    @property
+    def estimated_number_of_threads(self) -> int:
+        # At most `threads` in each worker + 2 additional threads (worker loop
+        # and heartbeat), mirroring Solid Queue's sizing heuristic.
+        max_worker_threads = max((w.threads for w in self.options.workers), default=1)
+        return max_worker_threads + 2
+
     @property
     def skip_recurring(self) -> bool:
         return self.options.skip_recurring or self.options.only_work

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue/models/recurring_execution.py

@@ -1,4 +1,4 @@
-from django.db import models
+from django.db import IntegrityError, models
 from django.tasks import TaskResult
 
 from .execution import Execution, ExecutionQuerySet
@@ -9,9 +9,10 @@ class RecurringExecutionQuerySet(ExecutionQuerySet):
         return self.filter(job__isnull=True)
 
     def record(self, task_result: TaskResult, task, run_at):
-        self.update_or_create(
-            task=task, run_at=run_at, defaults={"job_id": task_result.id}
-        )
+        try:
+            self.create(task=task, run_at=run_at, job_id=task_result.id)
+        except IntegrityError as e:
+            raise self.model.AlreadyRecorded from e
 
     def clear_in_batches(self, batch_size=500):
         while True:
@@ -21,6 +22,9 @@ class RecurringExecutionQuerySet(ExecutionQuerySet):
 
 
 class RecurringExecution(Execution):
+    class AlreadyRecorded(Exception):
+        pass
+
     class Meta:
         verbose_name = "recurring execution"
         verbose_name_plural = "recurring executions"

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue/models/recurring_task.py

@@ -97,7 +97,10 @@ class RecurringTask(UpdatedAtMixin, BaseModel):
         return self.recurring_executions.max("run_at")
 
     def enqueue(self, run_at: datetime):
-        return self.enqueue_and_record(run_at)
+        try:
+            return self.enqueue_and_record(run_at)
+        except RecurringExecution.AlreadyRecorded:
+            return False
 
     def enqueue_and_record(self, run_at: datetime):
         with transaction.atomic(using=self._state.db):
@@ -108,6 +111,7 @@ class RecurringTask(UpdatedAtMixin, BaseModel):
                 queue_name=self.queue_name, priority=self.priority
             ).enqueue(*args, **kwargs)
             RecurringExecution.objects.record(task_result, self, run_at)
+            return task_result
 
     @property
     def previous_time(self) -> datetime:

steady_queue-0.2.1/steady_queue/processes/base.py

@@ -0,0 +1,98 @@
+import logging
+import os
+import secrets
+import socket
+from typing import Any
+
+from django.db import connections
+
+logger = logging.getLogger("steady_queue")
+
+
+class Base:
+    name: str
+    stopped: bool = False
+
+    def __init__(self):
+        self.name = self.generate_name()
+        self.stopped = False
+
+    def boot(self):
+        pass
+
+    def shutdown(self):
+        pass
+
+    def stop(self):
+        self.stopped = True
+
+    @property
+    def kind(self) -> str:
+        return self.__class__.__name__.lower()
+
+    @property
+    def pid(self) -> int:
+        return os.getpid()
+
+    @property
+    def hostname(self) -> str:
+        return socket.gethostname()
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        return {}
+
+    @property
+    def is_stopped(self) -> bool:
+        return self.stopped
+
+    def generate_name(self) -> str:
+        return "-".join((self.kind, secrets.token_hex(10)))
+
+    def close_postgresql_connection_pools(self):
+        """
+        Close and clear Django's class-level psycopg pool cache.
+
+        Django stores psycopg pools in DatabaseWrapper._connection_pools, so we
+        must clear those references to avoid inheriting stale pools across fork.
+        """
+        closed_pool_maps: set[int] = set()
+
+        for alias in connections:
+            connection = connections[alias]
+            if (
+                connection.settings_dict.get("ENGINE")
+                != "django.db.backends.postgresql"
+            ):
+                continue
+
+            pool_map = getattr(connection.__class__, "_connection_pools", None)
+            if not isinstance(pool_map, dict) or id(pool_map) in closed_pool_maps:
+                continue
+
+            for pool_alias, pool in list(pool_map.items()):
+                try:
+                    pool.close()
+                    logger.debug(
+                        "%(name)s closed psycopg pool for '%(alias)s'",
+                        {"name": self.name, "alias": pool_alias},
+                    )
+                except Exception as e:
+                    logger.debug(
+                        "%(name)s failed to close pool for '%(alias)s': %(e)s",
+                        {"name": self.name, "alias": pool_alias, "e": e},
+                    )
+                finally:
+                    pool_map.pop(pool_alias, None)
+
+            closed_pool_maps.add(id(pool_map))
+
+    def reset_database_connections(self):
+        """
+        Reset database connections for forked processes.
+
+        This closes all current connections and clears Django's class-level
+        psycopg pool cache so child processes don't inherit parent pool state.
+        """
+        connections.close_all()
+        self.close_postgresql_connection_pools()

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue/processes/supervisor.py

@@ -43,6 +43,8 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         logger.info("starting supervisor with PID %(pid)d", {"pid": self.pid})
         try:
             self.boot()
+            # Fork only after resetting DB state (connections + psycopg pools).
+            self.reset_database_connections()
             self.start_processes()
             self.launch_maintenance_task()
         except SystemExit:
@@ -84,6 +86,9 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         instance.supervisor = self.process
         instance.mode = "fork"
 
+        # Replacement recovery queries the database after the startup reset.
+        # Clear that connection and pool state before the child inherits it.
+        self.reset_database_connections()
         if (pid := os.fork()) == 0:
             # child
             instance.start()

{steady_queue-0.1.8 → steady_queue-0.2.1/steady_queue.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.1.8
+Version: 0.2.1
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -10,12 +10,15 @@ Project-URL: Documentation, https://steady-queue.readthedocs.io/en/latest/
 Project-URL: Tracker, https://github.com/knifecake/steady-queue/issues
 Project-URL: Releases, https://github.com/knifecake/steady-queue/releases
 Keywords: django,tasks,async,jobs,queues
+Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 6.0
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
 Classifier: Natural Language :: English
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -63,6 +66,7 @@ The database backend exposed by Steady Queue doesn't support the following optio
   result = task.return_value` will result in an error (even if the task has
   completed processing). Instead, we recommend saving the results directly on
   your database or file storage system if they need to be kept around.
+- **Requires a POSIX system** due to the concurrency model based on `os.fork`. Steady Queue doesn't run on windows.
 
 The Steady Queue backend advertises these limitations by [setting the
 corresponding flags][django-tasks-flags] on its backend.

{steady_queue-0.1.8 → steady_queue-0.2.1}/steady_queue.egg-info/SOURCES.txt

@@ -73,10 +73,12 @@ tests/test_concurrency_controls.py
 tests/test_configuration.py
 tests/test_db_router.py
 tests/test_executions.py
+tests/test_fork_safety.py
 tests/test_job.py
 tests/test_pidfile.py
 tests/test_process_lifecycle.py
 tests/test_queue_selector.py
+tests/test_recurring_execution.py
 tests/test_recurring_task.py
 tests/test_semaphore.py
 tests/test_task.py

{steady_queue-0.1.8 → steady_queue-0.2.1}/tests/test_configuration.py

@@ -1,3 +1,4 @@
+import warnings
 from datetime import timedelta
 
 from django.core.exceptions import ValidationError
@@ -153,6 +154,54 @@ class ConfigurationValidationTestCase(SimpleTestCase):
         self.assertGreater(len(config.errors), 0)
         self.assertIn("No processes configured", str(config.errors[0]))
 
+    def test_small_postgres_pool_fails_validation(self):
+        """Configured worker threads must fit in postgres pool max_size."""
+        options = Configuration.Options(workers=[Configuration.Worker(threads=3)])
+        config = Configuration(options)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message="Overriding setting DATABASES can lead to unexpected behavior.",
+                category=UserWarning,
+            )
+
+            with self.settings(
+                DATABASES={
+                    "queue": {
+                        "ENGINE": "django.db.backends.postgresql",
+                        "OPTIONS": {"pool": {"min_size": 1, "max_size": 4}},
+                    }
+                }
+            ):
+                self.assertFalse(config.is_valid)
+
+        self.assertTrue(
+            any("pool max_size" in error.message for error in config.errors)
+        )
+
+    def test_sufficient_postgres_pool_passes_validation(self):
+        """Validation passes when postgres pool max_size is large enough."""
+        options = Configuration.Options(workers=[Configuration.Worker(threads=3)])
+        config = Configuration(options)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message="Overriding setting DATABASES can lead to unexpected behavior.",
+                category=UserWarning,
+            )
+
+            with self.settings(
+                DATABASES={
+                    "queue": {
+                        "ENGINE": "django.db.backends.postgresql",
+                        "OPTIONS": {"pool": {"min_size": 1, "max_size": 5}},
+                    }
+                }
+            ):
+                self.assertTrue(config.is_valid)
+
     def test_invalid_recurring_task_schedule_fails_validation(self):
         """Invalid cron schedule in recurring task fails validation."""
         invalid_task = Configuration.RecurringTask(

{steady_queue-0.1.8 → steady_queue-0.2.1}/tests/test_executions.py

@@ -1,6 +1,10 @@
+from concurrent.futures import ThreadPoolExecutor
 from datetime import timedelta
+from unittest import skipUnless
+from unittest.mock import patch
 
-from django.test import TestCase
+from django.db import connections
+from django.test import TestCase, TransactionTestCase
 from django.utils import timezone
 
 import steady_queue
@@ -14,6 +18,7 @@ from steady_queue.models import (
     ScheduledExecution,
     Semaphore,
 )
+from steady_queue.models.claimed_execution import ClaimedExecutionQuerySet
 from tests.dummy.tasks import dummy_task, limited_task, limited_task_with_lambda_key
 
 
@@ -106,6 +111,57 @@ class ReadyExecutionTestCase(TestHelperMixin, TestCase):
         self.assertEqual(ReadyExecution.objects.count(), 1)
 
 
+class ConcurrentClaimTestCase(TestHelperMixin, TransactionTestCase):
+    databases = {"default", "queue"}
+
+    @skipUnless(
+        connections["queue"].features.has_select_for_update_skip_locked,
+        "The queue database must support SELECT FOR UPDATE SKIP LOCKED",
+    )
+    def test_higher_priority_arrival_does_not_change_claimed_candidates(self):
+        """#25: keep the selected jobs stable across insertion and retrieval."""
+        process = self.create_test_process()
+        original = self.create_job_in_queue("default", priority=0)
+        bulk_create = ClaimedExecutionQuerySet.bulk_create
+
+        def enqueue_higher_priority_job():
+            try:
+                return self.create_job_in_queue("default", priority=10).pk
+            finally:
+                connections.close_all()
+
+        def insert_claims_then_enqueue(queryset, *args, **kwargs):
+            result = bulk_create(queryset, *args, **kwargs)
+            # Commit an arrival on another connection after claims are inserted,
+            # but before claiming() retrieves them. No sleeps or timing races.
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                arrival = executor.submit(enqueue_higher_priority_job)
+                arrivals.append(arrival.result(timeout=10))
+            return result
+
+        arrivals = []
+        with patch.object(
+            ClaimedExecutionQuerySet, "bulk_create", insert_claims_then_enqueue
+        ):
+            claimed = ReadyExecution.objects.claim(["*"], 1, process.pk)
+
+        self.assertEqual([execution.job_id for execution in claimed], [original.pk])
+        self.assertFalse(
+            ReadyExecution.objects.filter(
+                job_id__in=ClaimedExecution.objects.values("job_id")
+            ).exists()
+        )
+        self.assertEqual(
+            list(ReadyExecution.objects.values_list("job_id", flat=True)), arrivals
+        )
+
+        # Draining the remaining queue must not try to claim the original again.
+        next_claimed = ReadyExecution.objects.claim(["*"], 1, process.pk)
+        self.assertEqual([execution.job_id for execution in next_claimed], arrivals)
+        self.assertEqual(ReadyExecution.objects.claim(["*"], 1, process.pk), [])
+        self.assertEqual(ClaimedExecution.objects.count(), 2)
+
+
 class ClaimedExecutionTestCase(TestHelperMixin, TestCase):
     """Tests for ClaimedExecution behavior."""
 

steady_queue-0.2.1/tests/test_fork_safety.py

@@ -0,0 +1,183 @@
+from unittest import skipUnless
+from unittest.mock import patch
+
+from django.db import connections
+from django.test import SimpleTestCase, TransactionTestCase
+
+from steady_queue.configuration import Configuration
+from steady_queue.models import (
+    ClaimedExecution,
+    FailedExecution,
+    Job,
+    Process,
+    ReadyExecution,
+)
+from steady_queue.processes.base import Base
+from steady_queue.processes.supervisor import Supervisor
+from tests.dummy.tasks import dummy_task
+
+
+class SupervisorForkSafetyTest(SimpleTestCase):
+    def build_supervisor(self) -> Supervisor:
+        options = Configuration.Options(
+            workers=[],
+            dispatchers=[],
+            recurring_tasks=[],
+            skip_recurring=True,
+        )
+        return Supervisor(Configuration(options))
+
+    def test_supervisor_start_resets_connections_before_forking(self):
+        supervisor = self.build_supervisor()
+        calls = []
+
+        supervisor.boot = lambda: calls.append("boot")
+        supervisor.reset_database_connections = lambda: calls.append("reset")
+        supervisor.start_processes = lambda: calls.append("start_processes")
+        supervisor.launch_maintenance_task = lambda: calls.append("launch_maintenance")
+        supervisor.supervise = lambda: calls.append("supervise")
+
+        supervisor.start()
+
+        self.assertEqual(
+            calls,
+            [
+                "boot",
+                "reset",
+                "start_processes",
+                "launch_maintenance",
+                "supervise",
+            ],
+        )
+
+
+@skipUnless(
+    connections["queue"].vendor == "postgresql",
+    "Requires PostgreSQL connection pooling on the queue database",
+)
+class SupervisorPostgreSQLForkTest(TransactionTestCase):
+    databases = {"default", "queue"}
+
+    def setUp(self):
+        options = Configuration.Options(
+            workers=[], dispatchers=[], recurring_tasks=[], skip_recurring=True
+        )
+        self.supervisor = Supervisor(Configuration(options))
+        self.supervisor.register()
+        self.worker_config = Configuration.Process(
+            kind="worker", attributes=Configuration.Worker()
+        )
+        self.connection = connections["queue"]
+        self.pool_options = self.connection.settings_dict["OPTIONS"]["pool"].copy()
+        self.addCleanup(self.supervisor.reset_database_connections)
+
+    def assert_reset_at_fork(self):
+        # Intercept only the OS fork; exercise real Django connections, psycopg
+        # pools, and replacement recovery up to the boundary children inherit.
+        self.assertIsNone(self.connection.connection)
+        self.assertEqual(self.connection.__class__._connection_pools, {})
+        self.assertEqual(
+            self.connection.settings_dict["OPTIONS"]["pool"], self.pool_options
+        )
+        return 12346
+
+    def test_start_process_resets_open_connection_and_pool_before_fork(self):
+        self.assertIsNotNone(self.connection.connection)
+        self.assertIn("queue", self.connection.__class__._connection_pools)
+
+        with patch(
+            "steady_queue.processes.supervisor.os.fork",
+            side_effect=self.assert_reset_at_fork,
+        ) as fork:
+            self.supervisor.start_process(self.worker_config)
+
+        fork.assert_called_once_with()
+        self.assertIn(12346, self.supervisor.forks)
+        # Pooling remains usable by the parent after the reset.
+        self.assertTrue(Process.objects.filter(pk=self.supervisor.process.pk).exists())
+        self.assertIn("queue", self.connection.__class__._connection_pools)
+
+    def test_replacement_resets_connection_reopened_by_job_recovery(self):
+        old_worker = self.worker_config.instantiate()
+        self.addCleanup(old_worker.pool.shutdown)
+        registered_worker = Process.register(
+            kind="worker",
+            name=old_worker.name,
+            pid=12345,
+            hostname="test-host",
+            supervisor=self.supervisor.process,
+        )
+        job = Job.objects.enqueue(dummy_task, [], {})
+        ReadyExecution.objects.claim(["*"], 1, registered_worker.pk)
+        self.supervisor.forks[12345] = old_worker
+        self.supervisor.configured_processes[12345] = self.worker_config
+        self.supervisor.reset_database_connections()
+
+        with patch(
+            "steady_queue.processes.supervisor.os.fork",
+            side_effect=self.assert_reset_at_fork,
+        ) as fork:
+            self.supervisor.replace_fork(12345, 11)
+
+        fork.assert_called_once_with()
+        self.assertNotIn(12345, self.supervisor.forks)
+        self.assertIn(12346, self.supervisor.forks)
+        self.assertFalse(ClaimedExecution.objects.filter(job=job).exists())
+        self.assertTrue(FailedExecution.objects.filter(job=job).exists())
+
+
+class ResetDatabaseConnectionsTest(SimpleTestCase):
+    def test_reset_connections_clears_psycopg_pool_cache_without_disabling_pooling(
+        self,
+    ):
+        class FakePool:
+            def __init__(self):
+                self.closed = False
+
+            def close(self):
+                self.closed = True
+
+        class FakeConnection:
+            _connection_pools = {}
+
+            def __init__(self, engine: str):
+                self.settings_dict = {
+                    "ENGINE": engine,
+                    "OPTIONS": {"pool": {"min_size": 1, "max_size": 4}},
+                }
+
+        class FakeConnections(dict):
+            close_all_called = False
+
+            def __iter__(self):
+                return iter(self.keys())
+
+            def close_all(self):
+                self.close_all_called = True
+
+        pool_default = FakePool()
+        pool_queue = FakePool()
+        FakeConnection._connection_pools = {
+            "default": pool_default,
+            "queue": pool_queue,
+        }
+
+        fake_connections = FakeConnections(
+            {
+                "default": FakeConnection("django.db.backends.postgresql"),
+                "queue": FakeConnection("django.db.backends.postgresql"),
+                "sqlite": FakeConnection("django.db.backends.sqlite3"),
+            }
+        )
+
+        with patch("steady_queue.processes.base.connections", fake_connections):
+            Base().reset_database_connections()
+
+        self.assertIn("pool", fake_connections["default"].settings_dict["OPTIONS"])
+        self.assertIn("pool", fake_connections["queue"].settings_dict["OPTIONS"])
+        self.assertIn("pool", fake_connections["sqlite"].settings_dict["OPTIONS"])
+
+        self.assertTrue(fake_connections.close_all_called)
+        self.assertTrue(pool_default.closed)
+        self.assertTrue(pool_queue.closed)
+        self.assertEqual(FakeConnection._connection_pools, {})

{steady_queue-0.1.8 → steady_queue-0.2.1}/tests/test_process_lifecycle.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 from django.test import TestCase
 from django.utils import timezone
@@ -272,11 +272,11 @@ class PoolPostNilProcessTest(TestCase):
 
     def test_pool_post_does_not_access_execution_process(self):
         """Pool.post should not crash when execution.process is None."""
-        import time
-
         from steady_queue.processes.pool import Pool
 
-        pool = Pool(size=1, on_idle=lambda: None)
+        on_idle = MagicMock()
+        pool = Pool(size=1, on_idle=on_idle, worker_name="test-worker")
+        self.addCleanup(pool.executor.shutdown, wait=True)
 
         execution = MagicMock()
         execution.process = None
@@ -284,11 +284,25 @@ class PoolPostNilProcessTest(TestCase):
         execution.job.class_name = "test_task"
         execution.pk = 1
 
-        # Should not raise AttributeError
-        pool.post(execution)
-        # Give the thread pool time to execute
-        time.sleep(0.2)
-        pool.shutdown()
+        submit = pool.executor.submit
+        futures = []
+
+        def capture_future(*args, **kwargs):
+            future = submit(*args, **kwargs)
+            futures.append(future)
+            return future
+
+        with self.assertLogs("steady_queue", level="INFO") as logs:
+            with patch.object(pool.executor, "submit", capture_future):
+                pool.post(execution)
+            # Exceptions after perform() live in the Future. Checking only that
+            # perform() ran allowed the original #26 logging crash to pass.
+            futures[0].result(timeout=5)
 
-        # Verify perform was called successfully
         execution.perform.assert_called_once()
+        self.assertEqual(
+            logs.output,
+            ["INFO:steady_queue:test-worker completed job 1 test_task"],
+        )
+        self.assertEqual(pool.idle_threads, 1)
+        on_idle.assert_called_once_with()

steady_queue-0.2.1/tests/test_recurring_execution.py

@@ -0,0 +1,36 @@
+from django.test import TestCase
+from django.utils import timezone
+
+from steady_queue.configuration import Configuration
+from steady_queue.models import Job, RecurringExecution, RecurringTask
+from tests.dummy.tasks import dummy_task
+
+
+class RecurringExecutionTestCase(TestCase):
+    def test_enqueue_same_run_at_only_enqueues_once(self):
+        recurring_task = RecurringTask.from_configuration(
+            Configuration.RecurringTask(
+                key="test-recurring-task",
+                class_name="tests.dummy.tasks.dummy_task",
+                schedule="* * * * *",
+                arguments=dummy_task.serialize([], {}),
+                queue_name="default",
+                priority=0,
+            )
+        )
+        recurring_task.save()
+
+        run_at = timezone.now().replace(second=0, microsecond=0)
+
+        first_result = recurring_task.enqueue(run_at=run_at)
+        second_result = recurring_task.enqueue(run_at=run_at)
+
+        self.assertNotEqual(first_result, False)
+        self.assertFalse(second_result)
+
+        self.assertEqual(Job.objects.count(), 1)
+        self.assertEqual(RecurringExecution.objects.count(), 1)
+
+        recurring_execution = RecurringExecution.objects.get()
+        self.assertEqual(recurring_execution.task_id, recurring_task.key)
+        self.assertEqual(recurring_execution.run_at, run_at)

steady_queue-0.1.8/steady_queue/processes/base.py

@@ -1,102 +0,0 @@
-import os
-import secrets
-import socket
-from typing import Any
-
-from django.db import connections
-
-
-class Base:
-    name: str
-    stopped: bool = False
-
-    def __init__(self):
-        self.name = self.generate_name()
-        self.stopped = False
-
-    def boot(self):
-        pass
-
-    def shutdown(self):
-        pass
-
-    def stop(self):
-        self.stopped = True
-
-    @property
-    def kind(self) -> str:
-        return self.__class__.__name__.lower()
-
-    @property
-    def pid(self) -> int:
-        return os.getpid()
-
-    @property
-    def hostname(self) -> str:
-        return socket.gethostname()
-
-    @property
-    def metadata(self) -> dict[str, Any]:
-        return {}
-
-    @property
-    def is_stopped(self) -> bool:
-        return self.stopped
-
-    def generate_name(self) -> str:
-        return "-".join((self.kind, secrets.token_hex(10)))
-
-    def disable_connection_pooling(self):
-        """
-        Disable connection pooling for steady_queue processes.
-
-        Connection pooling with psycopg doesn't work with forked processes.
-        This method removes pool configuration from database settings to prevent
-        pool-related errors in steady_queue workers.
-        """
-        import logging
-
-        from django.conf import settings
-
-        logger = logging.getLogger("steady_queue")
-
-        # Disable pooling in database configuration
-        if hasattr(settings, "DATABASES"):
-            for alias, db_config in settings.DATABASES.items():
-                if db_config.get("ENGINE") == "django.db.backends.postgresql":
-                    # Remove pool configuration if it exists
-                    options = db_config.setdefault("OPTIONS", {})
-                    if "pool" in options:
-                        logger.info(
-                            "%(name)s disabling connection pooling for database '%(alias)s'",
-                            {"name": self.name, "alias": alias},
-                        )
-                        del options["pool"]
-
-        # Also disable on any existing connections
-        for alias in connections:
-            connection = connections[alias]
-            if hasattr(connection, "pool") and connection.pool is not None:
-                try:
-                    connection.pool.close()
-                    connection.pool = None
-                    logger.debug(
-                        "%(name)s removed existing pool for '%(alias)s'",
-                        {"name": self.name, "alias": alias},
-                    )
-                except Exception as e:
-                    logger.debug(
-                        "%(name)s failed to close existing pool for '%(alias)s': %(e)s",
-                        {"name": self.name, "alias": alias, "e": e},
-                    )
-
-    def reset_database_connections(self):
-        """
-        Reset database connections for forked processes.
-
-        This disables connection pooling and resets connection state to prevent
-        issues with shared connections between parent and child processes.
-        """
-        self.disable_connection_pooling()
-
-        connections.close_all()