redis_locks 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e54f88975c7c22202a262495733bef3bbf25384b
-  data.tar.gz: dd6f4a948434588a31ec2086b0bce9e90fb29680
+  metadata.gz: e975e1077350b297e9a2e29dd2c1874ee36015cd
+  data.tar.gz: 43c25d4b9302e7530cbbfcaa12c9f75f81ad51b8
 SHA512:
-  metadata.gz: 9c96f4d857b9461508678e335797dda5ffa2b625902ea43621b4af3c1b0efa59b10fd9c71448880dbef58abd2f8354afca7e4f7f9acc82ab435670fef506466f
-  data.tar.gz: ac7146e7944e074836d66eef2f12e908b637194151812ac9c96b689944ad66c5264f4029afb1612bae807e1eac0e2ddcb191715dd968efb19540752c2028837a
+  metadata.gz: 836660edb41f89794435460298714126fb583cfe95655c6d915061a2d42660412309804724fcf2c2749be0b59daa20bb446e6014d499ef8b85f058394b6c3363
+  data.tar.gz: f3ca402e401fbfc4a2cdac4167dc714ba327a7d58eb36d7b101fa875d2e77946d15c2876c757fb1523164e06a57c791e5df7e23b6d6da483e692d4b114569aff

data/README.md

@@ -16,7 +16,9 @@ A simple mutex using `setnx`.
   require 'redis'
   require 'redis_locks'
 
-  lock = RedisLocks::Mutex.new('my_key', redis: Redis.new)
+  RedisLocks.redis = Redis.new
+
+  lock = RedisLocks::Mutex.new('my_key')
 
   # high-level use
   lock.lock! do 
@@ -29,9 +31,8 @@ A simple mutex using `setnx`.
   lock.unlock # now lock can be acquired again
 ```
 
-Supports lock expiry via `expires_in`/`expires_at` arguments to the constructor.
-By default, locks expire after 24 hours.
-
+Supports lock expiry via an `expires_in` argument to the constructor or 
+`expires_at` argument to `lock`/`lock!`. By default, locks expire after 24 hours.
 
 ## RedisLocks::Semaphore
 
@@ -43,7 +44,9 @@ Supports multiple resources, waits to acquire a resource, and timeouts.
   require 'redis'
   require 'redis_locks'
 
-  semaphore = RedisLocks::Semaphore.new('my_key', redis: Redis.new, resources: 2)
+  RedisLocks.redis = Redis.new
+
+  semaphore = RedisLocks::Semaphore.new('my_key', resources: 2)
 
   # high-level use
   semaphore.lock! do
@@ -75,8 +78,10 @@ A [token-bucket](https://en.wikipedia.org/wiki/Token_bucket) rate limiter implem
   require 'redis'
   require 'redis_locks'
 
+  RedisLocks.redis = Redis.new
+
   # allows up to two calls to `take`/`take!` every five seconds
-  limiter = RedisLocks::TokenBucket.new('my_key', redis: Redis.new, period: 5, number: 2)
+  limiter = RedisLocks::TokenBucket.new('my_key', period: 5, number: 2)
 
   2.times { limiter.take! }
 

data/lib/redis_locks/mutex.rb

@@ -9,23 +9,26 @@ module RedisLocks
 
     NAMESPACE = "mutex"
 
-    def initialize(key, redis:, expires_in: 86400, expires_at: nil)
+    def initialize(key, expires_in: 86400, redis: RedisLocks.redis)
       @key = "#{NAMESPACE}:#{key}"
       @redis = redis
-      @expires_at = (expires_at.to_i if expires_at) || (Time.now.utc.to_i + expires_in)
+      @expires_in = expires_in.to_i
+
+      raise ArgumentError.new("Invalid expires_in: #{expires_in}") unless expires_in > 0
     end
 
-    def lock(&block)
+    def lock(expires_at: nil, &block)
       now = Time.now.utc.to_i
       locked = false
+      expires_at ||= now + @expires_in
 
-      if @redis.setnx(@key, @expires_at)
-        @redis.expire(@key, @expires_at - now)
+      if @redis.setnx(@key, expires_at)
+        @redis.expire(@key, expires_at - now)
         locked = true
       else # it was locked
         if (old_value = @redis.get(@key)).to_i <= now
           # lock has expired
-          if @redis.getset_value(@key, @expires_at) == old_value
+          if @redis.getset(@key, expires_at) == old_value
             locked = true
           end
         end
@@ -36,16 +39,22 @@ module RedisLocks
       return_or_yield(&block)
     end
 
-    def lock!(&block)
-      locked = lock
+    def lock!(expires_at: nil, &block)
+      locked = lock(expires_at: expires_at)
       raise AlreadyLocked.new(@key) unless locked
       return_or_yield(&block)
     end
 
-    # only delete the key if it's still valid, and will be for another 2 seconds
     def unlock
-      if Time.now.utc.to_i - 2 < @expires_at
-        @redis.del(@key)
+      @redis.watch(@key) do
+        # only delete the key if it's still valid, and will be for another 2 seconds
+        if @redis.get(@key).to_i > Time.now.utc.to_i + 2
+          @redis.multi do |multi|
+            multi.del(@key)
+          end
+        else
+          @redis.unwatch
+        end
       end
     end
 

data/lib/redis_locks/semaphore.rb

@@ -62,7 +62,7 @@ module RedisLocks
     #
     # `stale_client_timeout` is the threshold of time before we assume that
     # something has gone terribly wrong with a client and we invalidate its lock.
-    def initialize(key, redis:, resources: 1, stale_client_timeout: 86400)
+    def initialize(key, resources: 1, stale_client_timeout: 86400, redis: RedisLocks.redis)
       @key = key
       @resource_count = resources.to_i
       @stale_client_timeout = stale_client_timeout.to_f

data/lib/redis_locks/token_bucket.rb

@@ -41,7 +41,7 @@ module RedisLocks
     # max of `number` tokens being available). Each time a resource is used, a
     # token is removed from the bucket; if no tokens are available, no resource
     # may be used.
-    def initialize(key, redis:, period: 1, number: 1)
+    def initialize(key, period: 1, number: 1, redis: RedisLocks.redis)
       @key = "#{NAMESPACE}:#{key}".freeze
       @rps = number.to_f / period.to_i
       @burst = number.to_i

data/lib/redis_locks/version.rb

@@ -1,3 +1,3 @@
 module RedisLocks
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/redis_locks.rb

@@ -6,4 +6,14 @@ require 'redis_locks/semaphore'
 require 'redis_locks/token_bucket'
 
 module RedisLocks
+
+  def self.redis=(redis)
+    @redis = redis
+  end
+
+  def self.redis
+    raise "RedisLocks.redis is not set!" unless @redis
+    @redis
+  end
+
 end

data/spec/redis_locks/mutex_spec.rb

@@ -2,10 +2,7 @@ require 'spec_helper'
 
 describe RedisLocks::Mutex do
   let(:mutex) {
-    RedisLocks::Mutex.new(
-      'testmutex',
-      redis: $redis
-    )
+    RedisLocks::Mutex.new('testmutex')
   }
 
   it 'allows locking' do
@@ -31,7 +28,7 @@ describe RedisLocks::Mutex do
 
   context 'when locked' do
     before do
-       mutex.lock!
+      mutex.lock!
     end
 
     it 'does not allow locking again' do
@@ -58,4 +55,15 @@ describe RedisLocks::Mutex do
       end
     end
   end
+
+  context 'when locked but expired' do
+    before do
+      mutex.lock!(expires_at: Time.now.utc.to_i+1)
+      sleep(2)
+    end
+
+    it 'allows lock' do
+      expect(mutex.lock).to be_truthy
+    end
+  end
 end

data/spec/redis_locks/semaphore_spec.rb

@@ -5,7 +5,6 @@ describe RedisLocks::Semaphore do
     let(:semaphore) {
       RedisLocks::Semaphore.new(
         'testsemaphore',
-        redis: $redis,
         resources: 1
       )
     }
@@ -88,7 +87,6 @@ describe RedisLocks::Semaphore do
     let(:semaphore) {
       RedisLocks::Semaphore.new(
         'testsem',
-        redis: $redis,
         resources: 2
       )
     }

data/spec/redis_locks/token_bucket_spec.rb

@@ -5,7 +5,6 @@ describe RedisLocks::TokenBucket do
     let(:bucket) {
       RedisLocks::TokenBucket.new(
         "testbucket",
-        redis: $redis,
         period: 2,
         number: 2
       )

data/spec/spec_helper.rb

@@ -5,12 +5,14 @@ require 'redis'
 require 'redis_locks'
 require 'thread'
 
-$redis = Redis.new(db: ENV['REDIS_LOCKS_SPEC_DB'] || 15)
+redis = Redis.new(db: ENV['REDIS_LOCKS_SPEC_DB'] || 15)
 
-raise "#{$redis.inspect} is non-empty!" if $redis.keys.any?
+raise "#{redis.inspect} is non-empty!" if redis.keys.any?
+
+RedisLocks.redis = redis
 
 RSpec.configure do |config|
   config.after(:each) do
-    $redis.flushdb
+    redis.flushdb
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Academia.edu