ask-state-providers 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a565b9fd91fef16617d528d07fdde7dae5473875bf9f5c3dc652242bd61533a
-  data.tar.gz: 1b7ead2e8be6cb4ec13f3526360c1de9879ac2294b39c2006432be697ec163ba
+  metadata.gz: ca18027938f399b03eb670f65b4cd43af7f950b780a4e3808bb86f57dae070d2
+  data.tar.gz: cd930f6fc0836cb3a8570e058c5843faecbe82c6391cfe6ecb3ab4c80dd3fdc4
 SHA512:
-  metadata.gz: 9fa6bafae89e29ab87a23de46ab7f2cbe9fa672c101a9b3d2493631d0983856f55f0759817e7aa2298746c407ff365ef45b7fba149f43e337ccc63de5cf495fb
-  data.tar.gz: e4650a39f613ccaf7c2b5a35c63503bcb1d52aa77e04acf6be87624edf6b8626eaa05c5a3b0dc3bf4113b459f7b1d38f494fe1a46b0747573cc38b78e0ec674d
+  metadata.gz: d07655542453ce69b1095b7d4771290e1ce1ada5884aa94bf35cff45ba3af71c9f704ee126b586d5073335fe9d81a710fc9fe4d7c573ce9835eaac49974f88ce
+  data.tar.gz: 200b2e8a1a0f181589a13db0f43ea34b7b7f13cfd5ff5b410475bf9d85f57d54a6368b5337bc89bf1c2e5b7543a60354d63fa75255e6b46f4a3e50a39f80b67a

data/CHANGELOG.md

@@ -2,6 +2,57 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [0.4.8] — 2026-09-22
+
+### Changed
+
+- **Minimum `ask-core` raised to `>= 0.12.0`** (was `>= 0.11.4`) — aligns
+  the provider stack with the decision-vocabulary release of `ask-core`.
+
+### Fixed
+
+- **Provider lock contract hardened (token-safe release, TTL/expiry, cross-backend parity)**:
+
+  - **MySQL `acquire_lock` no longer hands a second contender a lock.**
+    Success was decided by `COUNT(*) > 0` on the key, so while an owner
+    held the lock, the next `acquire_lock` also returned a `Lock` —
+    exclusion was broken. It now uses one conditional upsert
+    (`ON DUPLICATE KEY UPDATE` that only takes over expired rows) and
+    reports success from `affected_rows`.
+  - **SQLite `acquire_lock` is atomic across processes.** The old
+    SELECT-then-DELETE-then-INSERT could delete a lock another process
+    had just granted. Replaced with a single
+    `INSERT … ON CONFLICT DO UPDATE … WHERE expires_at <= now
+    RETURNING token` that only takes over expired rows.
+  - **Postgres `acquire_lock` no longer races into `UniqueViolation`.**
+    DELETE-then-`INSERT … WHERE NOT EXISTS` let concurrent callers
+    collide on the primary key and raise instead of returning `nil`.
+    Now one `ON CONFLICT DO UPDATE … WHERE` upsert, verified by
+    `RETURNING token`.
+  - **Redis `acquire_lock` accepts non-positive TTLs.**
+    `SET … EX 0/-1` raised `invalid expire time`; it now returns an
+    already-expired lock without writing (and refuses when a live lock
+    is held), matching the SQL backends. Uses `PX` so whole-second and
+    sub-second TTLs share one path.
+  - **SQLite/Postgres/MySQL `release_lock` respects expiry.** They
+    deleted by key+token alone and returned `true` for an
+    expired-but-unreaped lock; the `Adapter` contract (and Memory/Redis)
+    return `false` once expired. Release now requires a matching token
+    **and** an unexpired lock.
+
+### Tests
+
+- **Shared `AdapterContract` lock coverage expanded** — five new
+  contract tests run against Memory, SQLite, Redis, Postgres, and MySQL:
+  release-after-expiry returns `false`, double release fails, a stale
+  owner cannot release the lock's replacement, `ttl: 0` grants no
+  exclusion, and `ttl:` lands in `expires_at`. Redis's
+  `test_lock_expired_can_be_acquired` skip is removed, and
+  `Ask::State::Memory` now runs the full shared contract
+  (`memory_contract_test.rb`).
+
 ## [0.4.1] — 2026-08-12
 
 ### Fixed

data/README.md

@@ -56,7 +56,7 @@ store.delete("user:1")
 Every backend implements `Ask::State::Adapter`:
 
 - Key-value: `get`, `set(key, value, ttl:)`, `delete`, `set_if_not_exists`, `keys(pattern:)`, `clear`
-- Distributed locking: `acquire_lock(key, ttl:)`, `release_lock(key, lock)`
+- Distributed locking: `acquire_lock(key, ttl:)`, `release_lock(key, lock)` — token-safe on every backend: `release_lock` returns `true` only while the caller still owns an unexpired lock; a stale owner (wrong token, lock timed out, or lock taken over) gets `false` and cannot free the new owner's lock.
 - Message queues: `enqueue(queue, value)`, `dequeue(queue)`
 - Ordered lists: `list_append(key, value, max_length:)`, `list_range(key, start, stop)`, `list_remove(key, value)`
 

data/lib/ask/state/providers/mysql.rb

@@ -153,33 +153,39 @@ module Ask
 
         def acquire_lock(key, ttl: 10)
           now = Time.now.utc
-          expires_at_time = now + ttl
+          expires_at = now + ttl
           token = SecureRandom.hex(16)
-          now_f = now.strftime("%Y-%m-%d %H:%M:%S.%3N")
-
-          # Clean up expired lock
-          @client.prepare("DELETE FROM locks WHERE `key` = ? AND expires_at <= ?").execute(key, now_f)
-
-          result = @client.prepare(<<~SQL).execute(key, expires_at_time.strftime("%Y-%m-%d %H:%M:%S.%3N"), token)
-            INSERT INTO locks (`key`, expires_at, token)
-            SELECT ?, ?, ?
-            WHERE NOT EXISTS (
-              SELECT 1 FROM locks WHERE `key` = ?
-            )
-          SQL
-          result = @client.prepare(<<~SQL).execute(key)
-            SELECT COUNT(*) AS cnt FROM locks WHERE `key` = ?
+          now_s = now.strftime("%Y-%m-%d %H:%M:%S.%3N")
+          expires_s = expires_at.strftime("%Y-%m-%d %H:%M:%S.%3N")
+
+          # One atomic upsert: insert when free; overwrite the row only
+          # when it has expired (IF keeps a live lock's token), so a
+          # contender can never displace an active owner. affected_rows
+          # is 1 for insert, 2 for takeover, 0 when a live lock won —
+          # the old COUNT(*) check could not tell "held by someone"
+          # from "held by me" and handed a second Lock to a contender.
+          stmt = @client.prepare(<<~SQL)
+            INSERT INTO locks (`key`, token, expires_at)
+            VALUES (?, ?, ?)
+            ON DUPLICATE KEY UPDATE
+              token = IF(expires_at <= ?, VALUES(token), token),
+              expires_at = IF(expires_at <= ?, VALUES(expires_at), expires_at)
           SQL
+          stmt.execute(key, token, expires_s, now_s, now_s)
 
-          # Check if we got the lock
-          row = result.first
-          return nil unless row && row["cnt"].to_i > 0
+          return nil unless @client.affected_rows > 0
 
-          Lock.new(id: key, token: token, expires_at: expires_at_time)
+          Lock.new(id: key, token: token, expires_at: expires_at)
         end
 
         def release_lock(key, lock)
-          @client.prepare("DELETE FROM locks WHERE `key` = ? AND token = ?").execute(key, lock.token)
+          # Token match plus unexpired: an owner whose lock has already
+          # timed out must not "release" a row nobody considers held
+          # (the Adapter contract returns false once expired).
+          stmt = @client.prepare(
+            "DELETE FROM locks WHERE `key` = ? AND token = ? AND expires_at > ?"
+          )
+          stmt.execute(key, lock.token, Time.now.utc.strftime("%Y-%m-%d %H:%M:%S.%3N"))
           @client.affected_rows > 0
         end
 

data/lib/ask/state/providers/postgres.rb

@@ -183,33 +183,40 @@ module Ask
 
         def acquire_lock(key, ttl: 10)
           now = Time.now.utc
-          expires_at_time = now + ttl
+          expires_at = now + ttl
           token = SecureRandom.hex(16)
 
-          acquired = with_connection do |conn|
-            # First clean up expired locks
-            conn.exec_params("DELETE FROM locks WHERE key = $1 AND expires_at <= $2",
-                           [key, now])
-
-            result = conn.exec_params(<<~SQL, [key, expires_at_time, token])
-              INSERT INTO locks (key, expires_at, token)
-              SELECT $1::text, $2::timestamptz, $3::text
-              WHERE NOT EXISTS (
-                SELECT 1 FROM locks
-                WHERE key = $1
-              )
+          row = with_connection do |conn|
+            # One atomic upsert: insert when free, take over only an
+            # expired row, leave a live lock's token untouched. This
+            # replaces DELETE-then-INSERT...WHERE NOT EXISTS, which let
+            # concurrent racers collide on the primary key and raise
+            # UniqueViolation instead of returning nil. A row comes back
+            # only when we won.
+            conn.exec_params(<<~SQL, [key, token, expires_at, now])
+              INSERT INTO locks (key, token, expires_at)
+              VALUES ($1::text, $2::text, $3::timestamptz)
+              ON CONFLICT (key) DO UPDATE SET
+                token = EXCLUDED.token,
+                expires_at = EXCLUDED.expires_at
+              WHERE locks.expires_at <= $4::timestamptz
+              RETURNING token
             SQL
-            result.cmd_tuples > 0
           end
 
-          acquired ? Lock.new(id: key, token: token, expires_at: expires_at_time) : nil
+          return nil unless row.ntuples > 0 && row[0]["token"] == token
+
+          Lock.new(id: key, token: token, expires_at: expires_at)
         end
 
         def release_lock(key, lock)
           with_connection do |conn|
+            # Token match plus unexpired: an owner whose lock has already
+            # timed out must not "release" a row nobody considers held
+            # (the Adapter contract returns false once expired).
             result = conn.exec_params(
-              "DELETE FROM locks WHERE key = $1 AND token = $2",
-              [key, lock.token]
+              "DELETE FROM locks WHERE key = $1 AND token = $2 AND expires_at > $3",
+              [key, lock.token, Time.now.utc]
             )
             result.cmd_tuples > 0
           end

data/lib/ask/state/providers/redis.rb

@@ -78,8 +78,20 @@ module Ask
           prefixed_key = prefixed("lock:#{key}")
           token = SecureRandom.hex(16)
           expires_at = Time.now + ttl
+          ttl_ms = (ttl.to_f * 1000).ceil
+
+          # Redis rejects non-positive expire times, so SET … EX 0/-1
+          # raised instead of behaving like the SQL backends. A ttl <= 0
+          # lock is already expired on arrival: report success only when
+          # the key is free and write nothing, so the next acquire gets
+          # through the way an expired SQL row would. PX (not EX) keeps
+          # whole-second and sub-second TTLs on the same code path.
+          acquired = if ttl_ms <= 0
+            @redis.call("EXISTS", prefixed_key) == 0
+          else
+            @redis.call("SET", prefixed_key, token, "NX", "PX", ttl_ms) == "OK"
+          end
 
-          acquired = @redis.call("SET", prefixed_key, token, "NX", "EX", ttl) == "OK"
           acquired ? Lock.new(id: key, token: token, expires_at: expires_at) : nil
         end
 

data/lib/ask/state/providers/sqlite.rb

@@ -132,31 +132,39 @@ module Ask
 
         def acquire_lock(key, ttl: 10)
           @mutex.synchronize do
-            now = Time.now.to_f
-            expires_at_time = Time.now + ttl
+            now = Time.now
+            expires_at = now + ttl
             token = SecureRandom.hex(16)
 
-            row = db.get_first_row(
-              "SELECT 1 FROM locks WHERE key = ? AND expires_at > ?",
-              [key, now]
-            )
-            return nil if row
-
-            db.execute("DELETE FROM locks WHERE key = ?", [key])
-            db.execute(<<~SQL, [key, expires_at_time.to_f, token])
-              INSERT INTO locks (key, expires_at, token)
+            # One atomic upsert: insert when the key is free, overwrite
+            # only when the held lock is expired, never touch a live one.
+            # The old SELECT-then-DELETE-then-INSERT let a second process
+            # delete a lock that had just been granted to someone else.
+            # A row comes back only when we won.
+            row = db.get_first_row(<<~SQL, [key, token, expires_at.to_f, now.to_f])
+              INSERT INTO locks (key, token, expires_at)
               VALUES (?, ?, ?)
+              ON CONFLICT(key) DO UPDATE SET
+                token = excluded.token,
+                expires_at = excluded.expires_at
+              WHERE locks.expires_at <= ?
+              RETURNING token
             SQL
 
-            Lock.new(id: key, token: token, expires_at: expires_at_time)
+            return nil unless row && row["token"] == token
+
+            Lock.new(id: key, token: token, expires_at: expires_at)
           end
         end
 
         def release_lock(key, lock)
           @mutex.synchronize do
+            # Token match plus unexpired: an owner whose lock has already
+            # timed out must not "release" a row nobody considers held
+            # (the Adapter contract returns false once expired).
             db.execute(
-              "DELETE FROM locks WHERE key = ? AND token = ?",
-              [key, lock.token]
+              "DELETE FROM locks WHERE key = ? AND token = ? AND expires_at > ?",
+              [key, lock.token, Time.now.to_f]
             )
             db.changes > 0
           end

data/lib/ask/state/providers/version.rb

@@ -3,7 +3,7 @@
 module Ask
   module State
     module Providers
-      VERSION = "0.4.7"
+      VERSION = "0.4.8"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-state-providers
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Kaka Ruto
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.4
+        version: 0.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.4
+        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement