taskito 0.16.1__tar.gz → 0.16.2__tar.gz

{taskito-0.16.1 → taskito-0.16.2}/Cargo.lock

@@ -112,9 +112,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"
-version = "1.2.63"
+version = "1.2.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f"
+checksum = "dad887fd958be91b5098c0248def011f4523ab786cd411be668777e55063501f"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -676,9 +676,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "js-sys"
-version = "0.3.100"
+version = "0.3.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2025f20d7a4fa7785846e7b63d10a76d3f1cee98ee5cb79ea59703f95e42162"
+checksum = "03d04c30968dffe80775bd4d7fb676131cd04a1fb46d2686dbffbaec2d9dfd31"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -821,9 +821,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.116"
+version = "0.9.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+checksum = "b47e7e6bb2c38cd930d25a23b40fa52e068c10e85f3e03a7f5ba5aaca5713695"
 dependencies = [
  "cc",
  "libc",
@@ -1403,7 +1403,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "taskito-async"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "async-trait",
  "crossbeam-channel",
@@ -1415,7 +1415,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-core"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1439,7 +1439,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-mesh"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "base64",
  "bincode",
@@ -1454,7 +1454,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-python"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "async-trait",
  "base64",
@@ -1475,7 +1475,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-workflows"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "dagron-core",
  "diesel",
@@ -1656,9 +1656,9 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasip2"
-version = "1.0.3+wasi-0.2.9"
+version = "1.0.4+wasi-0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
 dependencies = [
  "wit-bindgen 0.57.1",
 ]
@@ -1674,9 +1674,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.123"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a254a4b10c19a76f09a27640e7ffbf9bc30bf67e16a3bf28aaefa4920fe81563"
+checksum = "8ddb3f79143bced6de84270411622a2699cee572fc0875aeaf1e7867cf9fca1a"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1687,9 +1687,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.123"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24a40fc75b0ec6f3746ceb10d36f53a93dcd68a93b11b6445983945d79eba0dc"
+checksum = "4e21a184b13fb19e157296e2c46056aec9092264fab83e4ba59e68c61b323c3d"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1697,9 +1697,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.123"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "908f34bd9b9ce3d4caf07b72dfab63d61504d156856c6bd3cd87fa350cf3985b"
+checksum = "fecefd9c35bd935a20fc3fc344b5f29138961e4f47fb03297d88f2587afb5ebd"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1710,9 +1710,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.123"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7acbf7616c27b194bbb550bf77ed0c2c3e5b7fd1260a93082b95fb7f47959b92"
+checksum = "23939e44bb9a5d7576fa2b563dc2e136628f1224e88a8deed09e04858b77871f"
 dependencies = [
  "unicode-ident",
 ]

{taskito-0.16.1 → taskito-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskito
-Version: 0.16.1
+Version: 0.16.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-core"
-version = "0.16.1"
+version = "0.16.2"
 edition = "2021"
 
 [features]
@@ -32,3 +32,7 @@ redis = { workspace = true, optional = true }
 
 [dev-dependencies]
 tempfile = "3"
+# Raw connection access in the Redis contract tests, to set up race-window
+# state and assert on internal index keys. Only used by `#[cfg(feature = "redis")]`
+# tests; harmless when the feature is off.
+redis = { workspace = true }

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/scheduler/poller.rs

@@ -127,7 +127,7 @@ impl Scheduler {
         // If we exceed the cap, roll back: clear the claim row and reset
         // status to `Pending` so the job can be dispatched again later.
         if !self.check_post_claim_concurrency(&job)? {
-            self.rollback_claim_and_retry(&job.id, now + CONCURRENCY_RETRY_DELAY_MS)?;
+            self.rollback_claim_and_reschedule(&job.id, now + CONCURRENCY_RETRY_DELAY_MS)?;
             return Ok(false);
         }
 
@@ -140,14 +140,20 @@ impl Scheduler {
             Ok(()) => Ok(true),
             Err(TrySendError::Full(_)) => {
                 warn!("worker channel full; rescheduling job {job_id} (worker pool is behind)",);
-                self.rollback_claim_and_retry(&job_id, now + CHANNEL_BACKPRESSURE_RETRY_DELAY_MS)?;
+                self.rollback_claim_and_reschedule(
+                    &job_id,
+                    now + CHANNEL_BACKPRESSURE_RETRY_DELAY_MS,
+                )?;
                 Ok(false)
             }
             Err(TrySendError::Closed(_)) => {
                 warn!(
                     "worker channel closed; rescheduling job {job_id} (worker pool shutting down)",
                 );
-                self.rollback_claim_and_retry(&job_id, now + CHANNEL_BACKPRESSURE_RETRY_DELAY_MS)?;
+                self.rollback_claim_and_reschedule(
+                    &job_id,
+                    now + CHANNEL_BACKPRESSURE_RETRY_DELAY_MS,
+                )?;
                 Ok(false)
             }
         }
@@ -193,7 +199,7 @@ impl Scheduler {
                 let key = format!("queue:{}", job.queue);
                 if !self.rate_limiter.try_acquire(&key, rl_config)? {
                     self.storage
-                        .retry(&job.id, now + RATE_LIMIT_RETRY_DELAY_MS)?;
+                        .reschedule(&job.id, now + RATE_LIMIT_RETRY_DELAY_MS)?;
                     return Ok(false);
                 }
             }
@@ -202,14 +208,14 @@ impl Scheduler {
         if let Some(config) = self.task_configs.get(&job.task_name) {
             if config.circuit_breaker.is_some() && !self.circuit_breaker.allow(&job.task_name)? {
                 self.storage
-                    .retry(&job.id, now + CIRCUIT_BREAKER_RETRY_DELAY_MS)?;
+                    .reschedule(&job.id, now + CIRCUIT_BREAKER_RETRY_DELAY_MS)?;
                 return Ok(false);
             }
 
             if let Some(ref rl_config) = config.rate_limit {
                 if !self.rate_limiter.try_acquire(&job.task_name, rl_config)? {
                     self.storage
-                        .retry(&job.id, now + RATE_LIMIT_RETRY_DELAY_MS)?;
+                        .reschedule(&job.id, now + RATE_LIMIT_RETRY_DELAY_MS)?;
                     return Ok(false);
                 }
             }
@@ -265,11 +271,12 @@ impl Scheduler {
 
     /// Reverse a successful `claim_execution` and reschedule the job. Used
     /// when a post-claim gate rejects the job after the claim row has
-    /// already been written.
-    fn rollback_claim_and_retry(&self, job_id: &str, next_at: i64) -> Result<()> {
+    /// already been written. Uses `reschedule` (not `retry`) so a job that
+    /// never executed does not lose retry budget.
+    fn rollback_claim_and_reschedule(&self, job_id: &str, next_at: i64) -> Result<()> {
         if let Err(e) = self.storage.complete_execution(job_id) {
             warn!("failed to clear execution claim during rollback for job {job_id}: {e}");
         }
-        self.storage.retry(job_id, next_at)
+        self.storage.reschedule(job_id, next_at)
     }
 }

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/storage/diesel_common/jobs.rs

@@ -705,6 +705,31 @@ macro_rules! impl_diesel_job_ops {
                 Ok(())
             }
 
+            /// Re-schedule a job back to `Pending` without touching
+            /// `retry_count`. Mirrors [`retry`](Self::retry) for soft-gate
+            /// reschedules (rate limit, circuit breaker, concurrency cap,
+            /// backpressure) where the job never executed, so its retry
+            /// budget must be preserved.
+            pub fn reschedule(&self, id: &str, next_scheduled_at: i64) -> Result<()> {
+                let mut conn = self.conn()?;
+
+                let affected = diesel::update(jobs::table)
+                    .filter(jobs::id.eq(id))
+                    .set((
+                        jobs::status.eq(JobStatus::Pending as i32),
+                        jobs::scheduled_at.eq(next_scheduled_at),
+                        jobs::started_at.eq(None::<i64>),
+                        jobs::completed_at.eq(None::<i64>),
+                        jobs::error.eq(None::<String>),
+                    ))
+                    .execute(&mut conn)?;
+
+                if affected == 0 {
+                    return Err(QueueError::JobNotFound(id.to_string()));
+                }
+                Ok(())
+            }
+
             /// Cancel a pending job and cascade-cancel its dependents. The
             /// cancelled job moves from `jobs` into `archived_jobs`.
             pub fn cancel_job(&self, id: &str) -> Result<bool> {

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/storage/mod.rs

@@ -152,6 +152,9 @@ macro_rules! impl_storage {
             fn retry(&self, id: &str, next_scheduled_at: i64) -> $crate::error::Result<()> {
                 self.retry(id, next_scheduled_at)
             }
+            fn reschedule(&self, id: &str, next_scheduled_at: i64) -> $crate::error::Result<()> {
+                self.reschedule(id, next_scheduled_at)
+            }
             fn cancel_job(&self, id: &str) -> $crate::error::Result<bool> {
                 self.cancel_job(id)
             }
@@ -679,6 +682,9 @@ impl Storage for StorageBackend {
     fn retry(&self, id: &str, next_scheduled_at: i64) -> Result<()> {
         delegate!(self, retry, id, next_scheduled_at)
     }
+    fn reschedule(&self, id: &str, next_scheduled_at: i64) -> Result<()> {
+        delegate!(self, reschedule, id, next_scheduled_at)
+    }
     fn cancel_job(&self, id: &str) -> Result<bool> {
         delegate!(self, cancel_job, id)
     }

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/storage/redis_backend/dead_letter.rs

@@ -89,22 +89,38 @@ impl RedisStorage {
         let dlq_key = self.key(&["dlq", &dlq_id]);
         let dlq_all = self.key(&["dlq", "all"]);
 
-        let pipe = &mut redis::pipe();
-        pipe.set(&dlq_key, &json);
-        pipe.zadd(&dlq_all, &dlq_id, now as f64);
-        pipe.query::<()>(&mut conn).map_err(map_err)?;
-
-        // Archive the now-Dead job out of the live indices.
         let mut dead_job = job.clone();
         let old_status = dead_job.status;
         dead_job.status = JobStatus::Dead;
         dead_job.error = Some(error.to_string());
         dead_job.completed_at = Some(now);
-        self.archive_job_immediately(&mut conn, &dead_job, old_status)?;
+        let dead_json =
+            serde_json::to_string(&dead_job).map_err(|e| QueueError::Other(e.to_string()))?;
+
+        // Commit the DLQ entry and the live→archive move together, but only if the
+        // job is still live in its expected state. A racing complete/fail or the
+        // stale-job reaper may have archived it first; WATCH aborts the EXEC if
+        // `job:<id>` changes between the liveness check and the commit, so we never
+        // create a duplicate DLQ entry or overwrite a terminal archive.
+        let job_live_key = self.key(&["job", &job.id]);
+        let dead_lettered: bool =
+            redis::transaction(&mut conn, &[job_live_key.as_str()], |conn, pipe| {
+                if !conn.exists::<_, bool>(&job_live_key)? {
+                    return Ok(Some(false));
+                }
+                pipe.set(&dlq_key, &json).ignore();
+                pipe.zadd(&dlq_all, &dlq_id, now as f64).ignore();
+                self.push_archive_ops(pipe, &dead_job, old_status, &dead_json);
+                Ok(pipe.query::<Option<()>>(conn)?.map(|()| true))
+            })
+            .map_err(map_err)?;
 
-        // Cascade cancel dependents
+        // Cascade-cancel dependents only if we actually dead-lettered the job
+        // (skipped when a racer had already archived it).
         drop(conn);
-        self.cascade_cancel(&job.id, "dependency failed")?;
+        if dead_lettered {
+            self.cascade_cancel(&job.id, "dependency failed")?;
+        }
 
         Ok(())
     }

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/storage/redis_backend/jobs/dequeue.rs

@@ -6,7 +6,54 @@ use crate::error::{QueueError, Result};
 use crate::job::{Job, JobStatus};
 use crate::storage::redis_backend::{map_err, RedisStorage};
 
+/// Lua: claim a candidate by flipping it Pending→Running, but only if it is
+/// still a member of the pending status set (`jobs:status:0`). This is the
+/// Redis equivalent of the Diesel `UPDATE ... WHERE status = Pending`
+/// affected-row guard: a concurrent cancel/expire that already archived the
+/// job has removed it from `jobs:status:0`, so the claim is refused (returns 0)
+/// instead of resurrecting the job as a Running orphan. Redis runs the script
+/// atomically, which also closes the double-claim window between schedulers.
+///
+/// KEYS: job_key, pending_status_set, running_status_set, pending_zset
+/// ARGV: job_id, running_json
+const CLAIM_JOB_SCRIPT: &str = r#"
+    if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 0 then return 0 end
+    redis.call('SET', KEYS[1], ARGV[2])
+    redis.call('SREM', KEYS[2], ARGV[1])
+    redis.call('SADD', KEYS[3], ARGV[1])
+    redis.call('ZREM', KEYS[4], ARGV[1])
+    return 1
+"#;
+
 impl RedisStorage {
+    /// Atomically claim a candidate job (Pending→Running) via [`CLAIM_JOB_SCRIPT`].
+    /// The caller must have already set `job.status = Running` and `started_at`.
+    /// Returns `false` if the job was concurrently cancelled/expired/claimed, so
+    /// the dequeue scan should skip it.
+    fn claim_pending(
+        &self,
+        conn: &mut redis::Connection,
+        job: &Job,
+        queue_key: &str,
+    ) -> Result<bool> {
+        let job_json = serde_json::to_string(job).map_err(|e| QueueError::Other(e.to_string()))?;
+        let job_key = self.key(&["job", &job.id]);
+        let pending_status =
+            self.key(&["jobs", "status", &(JobStatus::Pending as i32).to_string()]);
+        let running_status =
+            self.key(&["jobs", "status", &(JobStatus::Running as i32).to_string()]);
+        let claimed: i32 = redis::Script::new(CLAIM_JOB_SCRIPT)
+            .key(&job_key)
+            .key(&pending_status)
+            .key(&running_status)
+            .key(queue_key)
+            .arg(&job.id)
+            .arg(&job_json)
+            .invoke(conn)
+            .map_err(map_err)?;
+        Ok(claimed == 1)
+    }
+
     pub fn dequeue(
         &self,
         queue_name: &str,
@@ -101,14 +148,13 @@ impl RedisStorage {
                 }
             }
 
-            // Claim the job
+            // Claim the job atomically; if we lost the race (cancelled / expired
+            // / claimed by another scheduler) skip to the next candidate.
             job.status = JobStatus::Running;
             job.started_at = Some(now);
-            self.save_job_and_move_status(&mut conn, &job, JobStatus::Pending)?;
-            conn.zrem::<_, _, ()>(&queue_key, &job_id)
-                .map_err(map_err)?;
-
-            return Ok(Some(job));
+            if self.claim_pending(&mut conn, &job, &queue_key)? {
+                return Ok(Some(job));
+            }
         }
 
         Ok(None)
@@ -240,14 +286,13 @@ impl RedisStorage {
                 }
             }
 
-            // Claim the job
+            // Claim the job atomically; skip candidates lost to a concurrent
+            // cancel / expire / claim instead of resurrecting them.
             job.status = JobStatus::Running;
             job.started_at = Some(now);
-            self.save_job_and_move_status(&mut conn, &job, JobStatus::Pending)?;
-            conn.zrem::<_, _, ()>(&queue_key, &job_id)
-                .map_err(map_err)?;
-
-            claimed.push(job);
+            if self.claim_pending(&mut conn, &job, &queue_key)? {
+                claimed.push(job);
+            }
         }
 
         Ok(claimed)

{taskito-0.16.1 → taskito-0.16.2}/crates/taskito-core/src/storage/redis_backend/jobs/helpers.rs

@@ -2,10 +2,23 @@
 
 use redis::Commands;
 
+use super::dequeue_score;
 use crate::error::{QueueError, Result};
 use crate::job::{Job, JobStatus};
 use crate::storage::redis_backend::{map_err, RedisStorage};
 
+/// Lua: release a unique-key pointer only if it still points at `ARGV[1]`.
+/// A newer job may have reused the same `unique_key` after this job left the
+/// live indices, so an unconditional `DEL` would clobber the new job's dedup
+/// lock. Mirrors `RELEASE_LOCK_SCRIPT` in `locks.rs`.
+const RELEASE_UNIQUE_IF_OWNER: &str = r#"
+    if redis.call('GET', KEYS[1]) == ARGV[1] then
+        redis.call('DEL', KEYS[1])
+        return 1
+    end
+    return 0
+"#;
+
 impl RedisStorage {
     pub(in crate::storage::redis_backend) fn load_job(
         &self,
@@ -74,22 +87,71 @@ impl RedisStorage {
         Ok(())
     }
 
-    /// Move a terminal job out of the live indices into the archive in a single
-    /// pipeline. Removes it from `job:<id>`, the live status / by_queue /
-    /// by_task sets and the `jobs:all` zset, then writes `archived:<id>`, adds
-    /// it to `archived:status:<n>` and scores it into `archived:all` by
-    /// completed_at.
+    /// Reset a job to `Pending` and (re)insert it into the per-queue pending
+    /// zset in a single MULTI/EXEC. Folding the status-set move and the zset
+    /// add into one transaction means a crash can no longer strand the job as
+    /// `Pending` in the status set but absent from the queue zset (where it
+    /// would never be dequeued and never reaped).
     ///
-    /// `old_status` is the status the job held in the live `jobs:status:<n>`
-    /// set; the caller must have already set the job's terminal `status`,
-    /// `completed_at` (and `error`/`result` as appropriate).
-    pub(in crate::storage::redis_backend) fn archive_job_immediately(
+    /// The caller must have already set the job's `status = Pending`,
+    /// `scheduled_at`, and cleared `started_at`/`completed_at`/`error`.
+    pub(in crate::storage::redis_backend) fn requeue_pending(
         &self,
         conn: &mut redis::Connection,
         job: &Job,
         old_status: JobStatus,
     ) -> Result<()> {
         let job_json = serde_json::to_string(job).map_err(|e| QueueError::Other(e.to_string()))?;
+        let job_key = self.key(&["job", &job.id]);
+        let old_status_key = self.key(&["jobs", "status", &(old_status as i32).to_string()]);
+        let pending_status_key =
+            self.key(&["jobs", "status", &(JobStatus::Pending as i32).to_string()]);
+        let queue_key = self.key(&["queue", &job.queue, "pending"]);
+        let score = dequeue_score(job.priority, job.scheduled_at);
+
+        let pipe = &mut redis::pipe();
+        pipe.atomic();
+        pipe.set(&job_key, &job_json);
+        if old_status != JobStatus::Pending {
+            pipe.srem(&old_status_key, &job.id);
+            pipe.sadd(&pending_status_key, &job.id);
+        }
+        pipe.zadd(&queue_key, &job.id, score);
+        pipe.query::<()>(conn).map_err(map_err)?;
+
+        Ok(())
+    }
+
+    /// Release a job's unique-key pointer iff it still belongs to this job, via
+    /// an atomic compare-and-delete (mirrors `RELEASE_LOCK_SCRIPT`). Safe to
+    /// call when a newer job may have reused the same `unique_key`.
+    pub(in crate::storage::redis_backend) fn release_unique_key(
+        &self,
+        conn: &mut redis::Connection,
+        unique_key: &str,
+        job_id: &str,
+    ) -> Result<()> {
+        let key = self.key(&["jobs", "unique", unique_key]);
+        redis::Script::new(RELEASE_UNIQUE_IF_OWNER)
+            .key(&key)
+            .arg(job_id)
+            .invoke::<i32>(conn)
+            .map_err(map_err)?;
+        Ok(())
+    }
+
+    /// Append the live→archive command sequence to `pipe` (no MULTI/EXEC of its
+    /// own). Removes the job from the live indices and writes the archived row.
+    /// Shared by `archive_job_immediately` and `move_to_dlq` so the DLQ write and
+    /// the archive can commit in one transaction. The caller must have already
+    /// set the terminal `status`/`completed_at` and serialized `job_json`.
+    pub(in crate::storage::redis_backend) fn push_archive_ops(
+        &self,
+        pipe: &mut redis::Pipeline,
+        job: &Job,
+        old_status: JobStatus,
+        job_json: &str,
+    ) {
         let completed_at = job.completed_at.unwrap_or_else(crate::job::now_millis);
 
         let job_key = self.key(&["job", &job.id]);
@@ -104,24 +166,38 @@ impl RedisStorage {
         let archived_by_queue = self.key(&["archived", "by_queue", &job.queue]);
         let archived_all = self.key(&["archived", "all"]);
 
-        // `.atomic()` wraps the live→archive move in MULTI/EXEC so the job is
-        // never observable in both the live and archived indices at once.
-        let pipe = &mut redis::pipe();
-        pipe.atomic();
-        pipe.del(&job_key);
-        pipe.srem(&status_key, &job.id);
-        pipe.srem(&by_queue_key, &job.id);
-        pipe.srem(&by_task_key, &job.id);
-        pipe.zrem(&all_key, &job.id);
+        // Results are ignored so callers can query the pipe as `()` (or
+        // `Option<()>` inside a WATCH transaction).
+        pipe.del(&job_key).ignore();
+        pipe.srem(&status_key, &job.id).ignore();
+        pipe.srem(&by_queue_key, &job.id).ignore();
+        pipe.srem(&by_task_key, &job.id).ignore();
+        pipe.zrem(&all_key, &job.id).ignore();
         // Pending jobs still sit in the per-queue pending zset; running jobs
         // were removed at dequeue, so only remove on a Pending→terminal move.
         if old_status == JobStatus::Pending {
-            pipe.zrem(&pending_key, &job.id);
+            pipe.zrem(&pending_key, &job.id).ignore();
         }
-        pipe.set(&archived_key, &job_json);
-        pipe.sadd(&archived_status_key, &job.id);
-        pipe.sadd(&archived_by_queue, &job.id);
-        pipe.zadd(&archived_all, &job.id, completed_at as f64);
+        pipe.set(&archived_key, job_json).ignore();
+        pipe.sadd(&archived_status_key, &job.id).ignore();
+        pipe.sadd(&archived_by_queue, &job.id).ignore();
+        pipe.zadd(&archived_all, &job.id, completed_at as f64)
+            .ignore();
+    }
+
+    /// Move a terminal job out of the live indices into the archive in one
+    /// atomic pipeline (`.atomic()` MULTI/EXEC), so it is never observable in
+    /// both the live and archived indices at once.
+    pub(in crate::storage::redis_backend) fn archive_job_immediately(
+        &self,
+        conn: &mut redis::Connection,
+        job: &Job,
+        old_status: JobStatus,
+    ) -> Result<()> {
+        let job_json = serde_json::to_string(job).map_err(|e| QueueError::Other(e.to_string()))?;
+        let pipe = &mut redis::pipe();
+        pipe.atomic();
+        self.push_archive_ops(pipe, job, old_status, &job_json);
         pipe.query::<()>(conn).map_err(map_err)?;
 
         Ok(())
@@ -153,21 +229,15 @@ impl RedisStorage {
         pipe.del(&errors_key);
         pipe.del(&deps_key);
         pipe.del(&dependents_key);
+        pipe.query::<()>(conn).map_err(map_err)?;
 
-        // Only release the unique-key pointer if it still points at THIS job.
-        // `enqueue_unique` stores the job id at `jobs:unique:<uk>`; a newer live
-        // job may have reused the same `unique_key` after this row was archived,
-        // and deleting the pointer would clobber the new job's lock.
+        // Release the unique-key pointer through the atomic compare-and-delete so
+        // a `enqueue_unique` that reused the key between a plain GET and DEL can't
+        // have its lock clobbered.
         if let Some(ref uk) = job.unique_key {
-            let unique_key = self.key(&["jobs", "unique", uk]);
-            let owner: Option<String> = conn.get(&unique_key).map_err(map_err)?;
-            if owner.as_deref() == Some(job.id.as_str()) {
-                pipe.del(&unique_key);
-            }
+            self.release_unique_key(conn, uk, &job.id)?;
         }
 
-        pipe.query::<()>(conn).map_err(map_err)?;
-
         Ok(())
     }
 }