redis-semaphore 0.2.4 → 0.3.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MjdjZjZhZWZiNmZiYTY1YWJkMWQ0ZDUyYmJjZGY2NGViMzQzZDhmMA==
-  data.tar.gz: !binary |-
-    MjI5YzlmMzBhOWE2ZmUwZTQyNjQ0Y2JjM2ZkMzZhOWEzMTc0YWZkOA==
+SHA1:
+  metadata.gz: 8b9f39ef8423ccca320813836891182abf1d93ec
+  data.tar.gz: f631ca62601208fe26125808c049abe755de3ad9
 SHA512:
-  metadata.gz: !binary |-
-    YzZjOTA0ZWQ2OWUzMzk2YTYyODA1ZWIzYjBiZmU1MTc5Yjg4MTk0MDZjYWYz
-    YjZiZTZlZTBmYzQ0MWFlNjFlNzFiODVjOTc4YjAyOWRiODUwYWY4MjNiNmYy
-    ZDAyZDEwOTZjZjk3ODVmMWIyNmJkNWZiYmEyMzM4ZDNjYmU2MTI=
-  data.tar.gz: !binary |-
-    MTdhN2RjYTRjMDIxMGJhNTM4YWM0YTViYzNjM2FjYmJmMjBmYjgwZGZjMDE0
-    MGNiZmM3YjI3OTJiNmU5OTAyZTZhNWVmOGFlNzQyZjMxNTYwZmIzMDY2NGU3
-    NTA4NTBkMGNiZjRhNmQzZjEyNjM4ZjMwNzFjYTI4YzgxZWFiYzg=
+  metadata.gz: 3c38139829552918fbc64bef11059fd3ac8a8117d6f25bbda7bfac2d355c791232d9a2b9c5458cc173d53b8d210b0aa01efd61e8c7aff6e1a5dc22253a6c1070
+  data.tar.gz: 0be29fe2f67e984c6e2757c0da6df45eba3ec8a97702cae4a623e185407e347f0642f624338ec66213c012e9f26220c71f4155e26cc1b9bd8a65ba65381689f9

data/README.md

@@ -10,6 +10,23 @@ The mutex and semaphore is blocking, not polling, and has a fair queue serving p
 
 For more info see [Wikipedia](http://en.wikipedia.org/wiki/Semaphore_(programming)).
 
+Important change in v0.3.0
+===========================
+
+If you've been using `redis-semaphore` before version `0.3.0` you should be aware that the interface for `lock` has changed slightly. Before `0.3` calling `semaphore.lock(0)` (with `0` as the timeout) would block the semaphore indefinitely, just like a redis `blpop` command would.
+
+This has changed in `0.3` to mean *do not block at all*. You can still omit the argument entirely, or pass in `nil` to get the old functionality back. Examples:
+
+```ruby
+# These block indefinitely until a resource becomes available:
+semaphore.lock
+semaphore.lock(nil)
+
+# This does not block at all and rather returns immediately if there's no
+# resource available:
+semaphore.lock(0)
+```
+
 Usage
 -----
 
@@ -81,6 +98,8 @@ s = Redis::Semaphore.new(:another_name, :redis => r)
 #...
 ```
 
+Note that it's [a bad idea to reuse the same redis client across threads](https://github.com/dv/redis-semaphore/issues/18), due to the blocking nature of the `blpop` command. We might add support for this in a future version.
+
 If an exception happens during a lock, the lock will automatically be released:
 
 ```ruby
@@ -200,54 +219,21 @@ Testing
 Changelog
 ---------
 
+###0.3.1 April 17, 2016 (Pending)
+- Fix `sem.lock(0)` bug (thanks eugenk!).
+- Fix `release_stale_locks!` deadlock bug (thanks mfischer-zd for the bug-report!).
+
+###0.3.0 January 24, 2016
+- Change API to include non-blocking option for `#lock` (thanks tomclose!).
+- Fix unwanted persisting of `available_key` (thanks dany1468!).
+- Fix `available_count` returning 0 for nonexisting semaphores (thanks mikeryz!).
+
 ###0.2.4 January 11, 2015
 - Fix bug with TIME and redis-namespace (thanks sos4nt!).
 - Add expiration option (thanks jcalvert!).
+- Update API version logic.
 
-###0.2.3 September 7, 2014
-- Block-based locking return the value of the block (thanks frobcode!).
-
-###0.2.2 June 16, 2014
-- Fixed bug in `all_tokens` (thanks presskey!).
-- Fixed bug in error message (thanks Dmitriy!).
-
-###0.2.1 August 6, 2013
-- Remove dependency on Redis 2.6+ using fallback for TIME command (thanks dubdromic!).
-- Add ```:use_local_time``` option
-
-###0.2.0 June 2, 2013
-- Use Redis TIME command for lock timeouts (thanks dubdromic!).
-- Version increase because of new dependency on Redis 2.6+
-
-###0.1.7 April 18, 2013
-- Fix bug where ```release_stale_locks!``` was not public (thanks scomma!).
-
-###0.1.6 March 31, 2013
-- Add non-ownership of tokens
-- Add stale client timeout (thanks timgaleckas!).
-
-###0.1.5 October 1, 2012
-- Add detection of Redis::Namespace definition to avoid potential bug (thanks ruud!).
-
-###0.1.4 October 1, 2012
-- Fixed empty namespaces (thanks ruurd!).
-
-###0.1.3 July 9, 2012
-- Tokens are now identifiable (thanks timgaleckas!).
-
-###0.1.2 June 1, 2012
-- Add redis-namespace support (thanks neovintage!).
-
-### 0.1.1 September 17, 2011
-- When an exception is raised during locked period, ensure it unlocks.
-
-### 0.1.0 August 4, 2011
-- Initial release.
-
-Author
-------
-
-[David Verhasselt](http://davidverhasselt.com) - david@crowdway.com
+More in [CHANGELOG](CHANGELOG.md).
 
 Contributors
 ------------
@@ -266,4 +252,11 @@ Thanks to these awesome people for their contributions:
 - [Petteri Räty](https://github.com/betelgeuse)
 - [Stefan Schüßler](https://github.com/sos4nt)
 - [Jonathan Calvert](https://github.com/jcalvert)
+- [mikeryz](https://github.com/mikeryz)
+- [tomclose](https://github.com/tomclose)
+- [Eugen Kuksa](https://github.com/eugenk)
+- [Eugene Kenny](https://github.com/eugeneius)
+
+### "Merge"-button clicker
 
+[David Verhasselt](http://davidverhasselt.com) - david@crowdway.com

data/lib/redis/semaphore.rb

@@ -37,13 +37,16 @@ class Redis
           @redis.set(version_key, API_VERSION)
         end
 
-        set_expiration_if_necessary
         true
       end
     end
 
     def available_count
-      @redis.llen(available_key)
+      if exists?
+        @redis.llen(available_key)
+      else
+        @resource_count
+      end
     end
 
     def delete!
@@ -53,14 +56,19 @@ class Redis
       @redis.del(version_key)
     end
 
-    def lock(timeout = 0)
+    def lock(timeout = nil)
       exists_or_create!
       release_stale_locks! if check_staleness?
 
-      token_pair = @redis.blpop(available_key, timeout)
-      return false if token_pair.nil?
+      if timeout.nil? || timeout > 0
+        # passing timeout 0 to blpop causes it to block
+        _key, current_token = @redis.blpop(available_key, timeout || 0)
+      else
+        current_token = @redis.lpop(available_key)
+      end
+
+      return false if current_token.nil?
 
-      current_token = token_pair[1]
       @tokens.push(current_token)
       @redis.hset(grabbed_key, current_token, current_time.to_f)
       return_value = current_token
@@ -100,6 +108,8 @@ class Redis
       @redis.multi do
         @redis.hdel grabbed_key, token
         @redis.lpush available_key, token
+
+        set_expiration_if_necessary
       end
     end
 
@@ -124,7 +134,7 @@ class Redis
     end
 
     def release_stale_locks!
-      simple_mutex(:release_locks, 10) do
+      simple_expiring_mutex(:release_locks, 10) do
         @redis.hgetall(grabbed_key).each do |token, locked_at|
           timed_out_at = locked_at.to_f + @stale_client_timeout
 
@@ -137,17 +147,37 @@ class Redis
 
   private
 
-    def simple_mutex(key_name, expires = nil)
-      key_name = namespaced_key(key_name) if key_name.kind_of? Symbol
-      token = @redis.getset(key_name, API_VERSION)
+    def simple_expiring_mutex(key_name, expires_in)
+      # Using the locking mechanism as described in
+      # http://redis.io/commands/setnx
+
+      key_name = namespaced_key(key_name)
+      cached_current_time = current_time.to_f
+      my_lock_expires_at = cached_current_time + expires_in + 1
+
+      got_lock = @redis.setnx(key_name, my_lock_expires_at)
+
+      if !got_lock
+        # Check if expired
+        other_lock_expires_at = @redis.get(key_name).to_f
+
+        if other_lock_expires_at < cached_current_time
+          old_expires_at = @redis.getset(key_name, my_lock_expires_at).to_f
+
+          # Check if another client started cleanup yet. If not,
+          # then we now have the lock.
+          got_lock = (old_expires_at == other_lock_expires_at)
+        end
+      end
 
-      return false unless token.nil?
-      @redis.expire(key_name, expires) unless expires.nil?
+      return false if !got_lock
 
       begin
-        yield token
+        yield
       ensure
-        @redis.del(key_name)
+        # Make sure not to delete the lock in case someone else already expired
+        # our lock, with one second in between to account for some lag.
+        @redis.del(key_name) if my_lock_expires_at > (current_time.to_f - 1)
       end
     end
 

data/spec/semaphore_spec.rb

@@ -22,6 +22,10 @@ describe "redis" do
       expect(semaphore.available_count).to eq(1)
     end
 
+    it "has the correct amount of available resources before locking" do
+      expect(semaphore.available_count).to eq(1)
+    end
+
     it "should not exist from the start" do
       expect(semaphore.exists?).to eq(false)
       semaphore.lock
@@ -89,9 +93,9 @@ describe "redis" do
     it "should not leave the semaphore locked after raising an exception" do
       expect {
         semaphore.lock(1) do
-          raise Exception
+          raise Exception, "redis semaphore exception"
         end
-      }.to raise_error
+      }.to raise_error(Exception, "redis semaphore exception")
 
       expect(semaphore.locked?).to eq(false)
     end
@@ -121,6 +125,24 @@ describe "redis" do
 
       expect(@redis.keys.count).to eq(original_key_size)
     end
+
+    it "should not block when the timeout is zero" do
+      did_we_get_in = false
+
+      semaphore.lock do
+        semaphore.lock(0) do
+          did_we_get_in = true
+        end
+      end
+
+      expect(did_we_get_in).to be false
+    end
+
+    it "should be locked when the timeout is zero" do
+      semaphore.lock(0) do
+        expect(semaphore.locked?).to be true
+      end
+    end
   end
 
   describe "semaphore with expiration" do
@@ -135,6 +157,15 @@ describe "redis" do
       sleep 3.0
       expect(@redis.keys.count).to eq(original_key_size)
     end
+
+    it "expires keys after unlocking" do
+      original_key_size = @redis.keys.count
+      semaphore.lock do
+        # noop
+      end
+      sleep 3.0
+      expect(@redis.keys.count).to eq(original_key_size)
+    end
   end
 
   describe "semaphore without staleness checking" do
@@ -243,4 +274,37 @@ describe "redis" do
     end
   end
 
+  # Private method tests, do not use
+  describe "simple_expiring_mutex" do
+    let(:semaphore) { Redis::Semaphore.new(:my_semaphore, :redis => @redis) }
+
+    before do
+      semaphore.class.send(:public, :simple_expiring_mutex)
+    end
+
+    it "gracefully expires stale lock" do
+      expiration = 1
+
+      thread =
+        Thread.new do
+          semaphore.simple_expiring_mutex(:test, expiration) do
+            sleep 3
+          end
+        end
+
+      sleep 1.5
+
+      expect(semaphore.simple_expiring_mutex(:test, expiration)).to be_falsy
+
+      sleep expiration
+
+      it_worked = false
+      semaphore.simple_expiring_mutex(:test, expiration) do
+        it_worked = true
+      end
+
+      expect(it_worked).to be_truthy
+      thread.join
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -5,3 +5,8 @@ Bundler.require(:development)
 $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'redis/semaphore'
+
+RSpec.configure do |c|
+  c.filter_run focus: true
+  c.run_all_when_everything_filtered = true
+end

metadata

@@ -1,98 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: redis-semaphore
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - David Verhasselt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-11 00:00:00.000000000 Z
+date: 2016-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.14'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! 'Implements a distributed semaphore or mutex using Redis.
-
-'
+description: |
+  Implements a distributed semaphore or mutex using Redis.
 email: david@crowdway.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - Rakefile
-- LICENSE
-- lib/redis/semaphore.rb
 - lib/redis-semaphore.rb
+- lib/redis/semaphore.rb
 - spec/semaphore_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/dv/redis-semaphore
@@ -105,19 +104,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Implements a distributed semaphore or mutex using Redis.
 test_files: []
-has_rdoc: