Reverting fixes (#155)

These fixes seem to get at least one of my systems into a state where
it's infinitely looping on perpetual tasks. This may have been due to
some of the intermediate problems in 0.9.0 and 0.9.1, but I don't want
to take that chance. We'll come back and revisit this.

This reverts commit 85f293c.

Revert "Fix WRONGTYPE error and add memory leak detection tests (#153)"

This reverts commit c2b8187.

Revert "Fix race condition in task replacement where duplicate
executions occur (#151)"

This reverts commit 9dc405c.

Author: chrisguidry

src/docket/docket.py

@@ -16,7 +16,6 @@
     Mapping,
     NoReturn,
     ParamSpec,
-    Protocol,
     Self,
     Sequence,
     TypedDict,
@@ -28,6 +27,7 @@
 import redis.exceptions
 from opentelemetry import propagate, trace
 from redis.asyncio import ConnectionPool, Redis
+from redis.asyncio.client import Pipeline
 from uuid_extensions import uuid7
 
 from .execution import (
@@ -55,18 +55,6 @@
 tracer: trace.Tracer = trace.get_tracer(__name__)
 
 
-class _schedule_task(Protocol):
-    async def __call__(
-        self, keys: list[str], args: list[str | float | bytes]
-    ) -> str: ...  # pragma: no cover
-
-
-class _cancel_task(Protocol):
-    async def __call__(
-        self, keys: list[str], args: list[str]
-    ) -> str: ...  # pragma: no cover
-
-
 P = ParamSpec("P")
 R = TypeVar("R")
 
@@ -143,8 +131,6 @@ async def my_task(greeting: str, recipient: str) -> None:
 
     _monitor_strikes_task: asyncio.Task[None]
     _connection_pool: ConnectionPool
-    _schedule_task_script: _schedule_task | None
-    _cancel_task_script: _cancel_task | None
 
     def __init__(
         self,
@@ -170,8 +156,6 @@ def __init__(
         self.url = url
         self.heartbeat_interval = heartbeat_interval
         self.missed_heartbeats = missed_heartbeats
-        self._schedule_task_script = None
-        self._cancel_task_script = None
 
     @property
     def worker_group_name(self) -> str:
@@ -316,7 +300,9 @@ async def scheduler(*args: P.args, **kwargs: P.kwargs) -> Execution:
             execution = Execution(function, args, kwargs, when, key, attempt=1)
 
             async with self.redis() as redis:
-                await self._schedule(redis, execution, replace=False)
+                async with redis.pipeline() as pipeline:
+                    await self._schedule(redis, pipeline, execution, replace=False)
+                    await pipeline.execute()
 
             TASKS_ADDED.add(1, {**self.labels(), **execution.general_labels()})
             TASKS_SCHEDULED.add(1, {**self.labels(), **execution.general_labels()})
@@ -375,7 +361,9 @@ async def scheduler(*args: P.args, **kwargs: P.kwargs) -> Execution:
             execution = Execution(function, args, kwargs, when, key, attempt=1)
 
             async with self.redis() as redis:
-                await self._schedule(redis, execution, replace=True)
+                async with redis.pipeline() as pipeline:
+                    await self._schedule(redis, pipeline, execution, replace=True)
+                    await pipeline.execute()
 
             TASKS_REPLACED.add(1, {**self.labels(), **execution.general_labels()})
             TASKS_CANCELLED.add(1, {**self.labels(), **execution.general_labels()})
@@ -395,7 +383,9 @@ async def schedule(self, execution: Execution) -> None:
             },
         ):
             async with self.redis() as redis:
-                await self._schedule(redis, execution, replace=False)
+                async with redis.pipeline() as pipeline:
+                    await self._schedule(redis, pipeline, execution, replace=False)
+                    await pipeline.execute()
 
         TASKS_SCHEDULED.add(1, {**self.labels(), **execution.general_labels()})
 
@@ -410,7 +400,9 @@ async def cancel(self, key: str) -> None:
             attributes={**self.labels(), "docket.key": key},
         ):
             async with self.redis() as redis:
-                await self._cancel(redis, key)
+                async with redis.pipeline() as pipeline:
+                    await self._cancel(pipeline, key)
+                    await pipeline.execute()
 
         TASKS_CANCELLED.add(1, self.labels())
 
@@ -428,23 +420,13 @@ def known_task_key(self, key: str) -> str:
     def parked_task_key(self, key: str) -> str:
         return f"{self.name}:{key}"
 
-    def stream_id_key(self, key: str) -> str:
-        return f"{self.name}:stream-id:{key}"
-
     async def _schedule(
         self,
         redis: Redis,
+        pipeline: Pipeline,
         execution: Execution,
         replace: bool = False,
     ) -> None:
-        """Schedule a task atomically.
-
-        Handles:
-        - Checking for task existence
-        - Cancelling existing tasks when replacing
-        - Adding tasks to stream (immediate) or queue (future)
-        - Tracking stream message IDs for later cancellation
-        """
         if self.strike_list.is_stricken(execution):
             logger.warning(
                 "%r is stricken, skipping schedule of %r",
@@ -467,138 +449,32 @@ async def _schedule(
         key = execution.key
         when = execution.when
         known_task_key = self.known_task_key(key)
-        is_immediate = when <= datetime.now(timezone.utc)
 
-        # Lock per task key to prevent race conditions between concurrent operations
         async with redis.lock(f"{known_task_key}:lock", timeout=10):
-            if self._schedule_task_script is None:
-                self._schedule_task_script = cast(
-                    _schedule_task,
-                    redis.register_script(
-                        # KEYS: stream_key, known_key, parked_key, queue_key, stream_id_key
-                        # ARGV: task_key, when_timestamp, is_immediate, replace, ...message_fields
-                        """
-                        local stream_key = KEYS[1]
-                        local known_key = KEYS[2]
-                        local parked_key = KEYS[3]
-                        local queue_key = KEYS[4]
-                        local stream_id_key = KEYS[5]
-
-                        local task_key = ARGV[1]
-                        local when_timestamp = ARGV[2]
-                        local is_immediate = ARGV[3] == '1'
-                        local replace = ARGV[4] == '1'
-
-                        -- Extract message fields from ARGV[5] onwards
-                        local message = {}
-                        for i = 5, #ARGV, 2 do
-                            message[#message + 1] = ARGV[i]     -- field name
-                            message[#message + 1] = ARGV[i + 1] -- field value
-                        end
-
-                        -- Handle replacement: cancel existing task if needed
-                        if replace then
-                            local existing_message_id = redis.call('GET', stream_id_key)
-                            if existing_message_id then
-                                redis.call('XDEL', stream_key, existing_message_id)
-                            end
-                            redis.call('DEL', known_key, parked_key, stream_id_key)
-                            redis.call('ZREM', queue_key, task_key)
-                        else
-                            -- Check if task already exists
-                            if redis.call('EXISTS', known_key) == 1 then
-                                return 'EXISTS'
-                            end
-                        end
-
-                        if is_immediate then
-                            -- Add to stream and store message ID for later cancellation
-                            local message_id = redis.call('XADD', stream_key, '*', unpack(message))
-                            redis.call('SET', known_key, when_timestamp)
-                            redis.call('SET', stream_id_key, message_id)
-                            return message_id
-                        else
-                            -- Add to queue with task data in parked hash
-                            redis.call('SET', known_key, when_timestamp)
-                            redis.call('HSET', parked_key, unpack(message))
-                            redis.call('ZADD', queue_key, when_timestamp, task_key)
-                            return 'QUEUED'
-                        end
-                        """
-                    ),
-                )
-            schedule_task = self._schedule_task_script
+            if replace:
+                await self._cancel(pipeline, key)
+            else:
+                # if the task is already in the queue or stream, retain it
+                if await redis.exists(known_task_key):
+                    logger.debug(
+                        "Task %r is already in the queue or stream, not scheduling",
+                        key,
+                        extra=self.labels(),
+                    )
+                    return
 
-            await schedule_task(
-                keys=[
-                    self.stream_key,
-                    known_task_key,
-                    self.parked_task_key(key),
-                    self.queue_key,
-                    self.stream_id_key(key),
-                ],
-                args=[
-                    key,
-                    str(when.timestamp()),
-                    "1" if is_immediate else "0",
-                    "1" if replace else "0",
-                    *[
-                        item
-                        for field, value in message.items()
-                        for item in (field, value)
-                    ],
-                ],
-            )
+            pipeline.set(known_task_key, when.timestamp())
 
-    async def _cancel(self, redis: Redis, key: str) -> None:
-        """Cancel a task atomically.
+            if when <= datetime.now(timezone.utc):
+                pipeline.xadd(self.stream_key, message)  # type: ignore[arg-type]
+            else:
+                pipeline.hset(self.parked_task_key(key), mapping=message)  # type: ignore[arg-type]
+                pipeline.zadd(self.queue_key, {key: when.timestamp()})
 
-        Handles cancellation regardless of task location:
-        - From the stream (using stored message ID)
-        - From the queue (scheduled tasks)
-        - Cleans up all associated metadata keys
-        """
-        if self._cancel_task_script is None:
-            self._cancel_task_script = cast(
-                _cancel_task,
-                redis.register_script(
-                    # KEYS: stream_key, known_key, parked_key, queue_key, stream_id_key
-                    # ARGV: task_key
-                    """
-                    local stream_key = KEYS[1]
-                    local known_key = KEYS[2]
-                    local parked_key = KEYS[3]
-                    local queue_key = KEYS[4]
-                    local stream_id_key = KEYS[5]
-                    local task_key = ARGV[1]
-
-                    -- Delete from stream if message ID exists
-                    local message_id = redis.call('GET', stream_id_key)
-                    if message_id then
-                        redis.call('XDEL', stream_key, message_id)
-                    end
-
-                    -- Clean up all task-related keys
-                    redis.call('DEL', known_key, parked_key, stream_id_key)
-                    redis.call('ZREM', queue_key, task_key)
-
-                    return 'OK'
-                    """
-                ),
-            )
-        cancel_task = self._cancel_task_script
-
-        # Execute the cancellation script
-        await cancel_task(
-            keys=[
-                self.stream_key,
-                self.known_task_key(key),
-                self.parked_task_key(key),
-                self.queue_key,
-                self.stream_id_key(key),
-            ],
-            args=[key],
-        )
+    async def _cancel(self, pipeline: Pipeline, key: str) -> None:
+        pipeline.delete(self.known_task_key(key))
+        pipeline.delete(self.parked_task_key(key))
+        pipeline.zrem(self.queue_key, key)
 
     @property
     def strike_key(self) -> str:
@@ -905,7 +781,6 @@ async def clear(self) -> int:
                         key = key_bytes.decode()
                         pipeline.delete(self.parked_task_key(key))
                         pipeline.delete(self.known_task_key(key))
-                        pipeline.delete(self.stream_id_key(key))
 
                     await pipeline.execute()
 

src/docket/worker.py

@@ -495,8 +495,7 @@ async def _delete_known_task(
 
         logger.debug("Deleting known task", extra=self._log_context())
         known_task_key = self.docket.known_task_key(key)
-        stream_id_key = self.docket.stream_id_key(key)
-        await redis.delete(known_task_key, stream_id_key)
+        await redis.delete(known_task_key)
 
     async def _execute(self, execution: Execution) -> None:
         log_context = {**self._log_context(), **execution.specific_labels()}

tests/test_fundamentals.py

@@ -104,9 +104,13 @@ async def test_adding_is_idempotent(
     assert soon <= now() < later
 
 
+@pytest.mark.skip(
+    "Temporarily skipping due to test flake for task rescheduling. "
+    "See https://github.com/chrisguidry/docket/issues/149"
+)
 async def test_rescheduling_later(
     docket: Docket, worker: Worker, the_task: AsyncMock, now: Callable[[], datetime]
-):
+):  # pragma: no cover
     """docket should allow for rescheduling a task for later"""
 
     key = f"my-cool-task:{uuid4()}"
@@ -250,39 +254,18 @@ async def test_cancelling_future_task(
     the_task.assert_not_called()
 
 
-async def test_cancelling_immediate_task(
+async def test_cancelling_current_task_not_supported(
     docket: Docket, worker: Worker, the_task: AsyncMock, now: Callable[[], datetime]
 ):
-    """docket can cancel a task that is scheduled immediately"""
+    """docket does not allow cancelling a task that is schedule now"""
 
     execution = await docket.add(the_task, now())("a", "b", c="c")
 
     await docket.cancel(execution.key)
 
     await worker.run_until_finished()
 
-    the_task.assert_not_called()
-
-
-async def test_cancellation_is_idempotent(
-    docket: Docket, worker: Worker, the_task: AsyncMock, now: Callable[[], datetime]
-):
-    """Test that canceling the same task twice doesn't error."""
-    key = f"test-task:{uuid4()}"
-
-    # Schedule a task
-    later = now() + timedelta(seconds=1)
-    await docket.add(the_task, later, key=key)("test")
-
-    # Cancel it twice - both should succeed without error
-    await docket.cancel(key)
-    await docket.cancel(key)  # Should be idempotent
-
-    # Run worker to ensure the task was actually cancelled
-    await worker.run_until_finished()
-
-    # Task should not have been executed since it was cancelled
-    the_task.assert_not_called()
+    the_task.assert_awaited_once_with("a", "b", c="c")
 
 
 async def test_errors_are_logged(