redis-read-write-locks 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea7b9828f43be08a2e5cf9442c3fcc4704a93297934305d4688d4439e44b22a7
-  data.tar.gz: 317dbc6377d5e429d538e4c046043bbcbe694bdd8c2a01119ebbd0b16aff4f3d
+  metadata.gz: cf0e4824a200a3a7edd4b4dfe626ebfb8cb243b69ed87ebeba49f8e545067708
+  data.tar.gz: 24165395045c8fb6ab49d243beeb711d693efbbb79d709b4bb680e6a94947566
 SHA512:
-  metadata.gz: 17a5fd925b81b59c5639b9f7225766ee0986f472b6eb87759aedff9ebb70f1f78470c5f4cae1750e18e048d3142af11cadf41f0a81cd759fe5c9682cb1337db0
-  data.tar.gz: 44474007063f41629590bd8e29822bf3532af425ec0d2099e649e25dedd79256cf4a5eaaca12e48fd62d5ffd3e295605175f704d758ec043c4862bbfec5787b6
+  metadata.gz: 93156958fcdb655a7539aa1dc00f5d2ba8a287d374f3eedd65352bff7af1ac27a031058d1bba1db04afa8c99af72bde2ca9c2763797ddb48f2d0fd5bf839bea8
+  data.tar.gz: be70fc26075e27252d6070c1770ad1aa0ca8cdfece6b85aa6ac226db41d522878a4d0aebb847535da029666f2f778ddb6f51ac69a43cffcc2d8891b32eaea4c2

data/README.md

@@ -30,18 +30,18 @@ lock = client.read_lock("my_resource")
 lock.acquire          # => true / false (non-blocking)
 lock.release
 
-# Block on contention — retries for up to N seconds
-lock.acquire(timeout: 5)          # raises LockTimeoutError if timeout exceeded
-lock.synchronize(timeout: 5) { }  # acquire + yield + release
+# Block on contention — retries for up to N milliseconds
+lock.acquire(timeout: 5000)          # raises LockTimeoutError if timeout exceeded
+lock.synchronize(timeout: 5000) { }  # acquire + yield + release
 
 # Per-lock TTL override
-client.write_lock("my_resource", ttl: 60) { long_operation }
+client.write_lock("my_resource", ttl: 60_000) { long_operation }
 ```
 
 ### Client options
 
 ```ruby
-client = RedisReadWriteLocks::Client.new(redis, default_ttl: 60)
+client = RedisReadWriteLocks::Client.new(redis, default_ttl: 60_000)
 ```
 
 ### Options

data/lib/redis_read_write_locks/base_lock.rb

@@ -2,8 +2,8 @@ require "securerandom"
 
 module RedisReadWriteLocks
   class BaseLock
-    DEFAULT_TTL = 30
-    RETRY_INTERVAL = 0.01
+    DEFAULT_TTL = 30_000
+    DEFAULT_RETRY_DELAY = 100
 
     attr_reader :name, :token
 
@@ -19,23 +19,20 @@ module RedisReadWriteLocks
       @acquired
     end
 
-    # Non-blocking: returns true/false.
-    # With timeout: retries for timeout seconds, returns true or raises LockTimeoutError.
-    def acquire(timeout: nil)
-      return try_acquire if timeout.nil?
+    def acquire(retry_count: nil, retry_delay: DEFAULT_RETRY_DELAY)
+      return try_acquire if retry_count.nil?
 
-      deadline = Time.now.to_f + timeout
-      loop do
+      return true if try_acquire
+      retry_count.times do
+        sleep retry_delay / 1000.0
         return true if try_acquire
-        raise LockTimeoutError, "Timeout acquiring #{lock_type} lock '#{@name}'" if Time.now.to_f >= deadline
-        sleep RETRY_INTERVAL
       end
+      raise LockTimeoutError, "Could not acquire #{lock_type} lock '#{@name}' after #{retry_count} retries"
     end
 
-    # Acquires lock, yields, releases. Raises LockNotAcquiredError if non-blocking acquire fails.
-    def synchronize(timeout: nil, &block)
-      if timeout
-        acquire(timeout: timeout)
+    def synchronize(retry_count: nil, retry_delay: DEFAULT_RETRY_DELAY, &block)
+      if retry_count
+        acquire(retry_count: retry_count, retry_delay: retry_delay)
       else
         acquire || raise(LockNotAcquiredError, "Could not acquire #{lock_type} lock '#{@name}'")
       end

data/lib/redis_read_write_locks/client.rb

@@ -5,14 +5,14 @@ module RedisReadWriteLocks
       @default_ttl = default_ttl
     end
 
-    def read_lock(name, ttl: @default_ttl, &block)
+    def read_lock(name, ttl: @default_ttl, retry_count: nil, retry_delay: BaseLock::DEFAULT_RETRY_DELAY, &block)
       lock = ReadLock.new(redis: @redis, name: name, ttl: ttl)
-      block ? lock.synchronize(&block) : lock
+      block ? lock.synchronize(retry_count: retry_count, retry_delay: retry_delay, &block) : lock
     end
 
-    def write_lock(name, ttl: @default_ttl, &block)
+    def write_lock(name, ttl: @default_ttl, retry_count: nil, retry_delay: BaseLock::DEFAULT_RETRY_DELAY, &block)
       lock = WriteLock.new(redis: @redis, name: name, ttl: ttl)
-      block ? lock.synchronize(&block) : lock
+      block ? lock.synchronize(retry_count: retry_count, retry_delay: retry_delay, &block) : lock
     end
   end
 end

data/lib/redis_read_write_locks/read_lock.rb

@@ -12,7 +12,7 @@ module RedisReadWriteLocks
 
     def try_acquire
       now = Time.now.to_i
-      expiry = now + @ttl
+      expiry = now + @ttl / 1000
 
       result = eval_script(
         LockScripts::ACQUIRE_READ,

data/lib/redis_read_write_locks/version.rb

@@ -1,3 +1,3 @@
 module RedisReadWriteLocks
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/redis_read_write_locks/write_lock.rb

@@ -14,7 +14,7 @@ module RedisReadWriteLocks
       result = eval_script(
         LockScripts::ACQUIRE_WRITE,
         keys: [writer_key, readers_key],
-        argv: [@token, @ttl, Time.now.to_i],
+        argv: [@token, @ttl / 1000, Time.now.to_i],
       )
 
       @acquired = result == 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-read-write-locks
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Umbrellio