redis-semaphore 0.2.3.1 → 0.2.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NThjZDI5NWY4MjY4Zjc2OWU3ODgxMTUwYjM1NDMyNjEyNjU0ZmY3YQ==
+    MjdjZjZhZWZiNmZiYTY1YWJkMWQ0ZDUyYmJjZGY2NGViMzQzZDhmMA==
   data.tar.gz: !binary |-
-    MTMzNTlhMjUxZjY3Mzg2ZDAzNWQwMjgxNGUxYzUzNDQ5NTFlMDA3YQ==
+    MjI5YzlmMzBhOWE2ZmUwZTQyNjQ0Y2JjM2ZkMzZhOWEzMTc0YWZkOA==
 SHA512:
   metadata.gz: !binary |-
-    MTRiMjNkYTdlYWQ3OTkxY2MwYTI0NjIyNzcyM2U0NjQ3MTRhNWRhM2VmNDNk
-    MDJkZDUzODE5NWQ5ZjE4YWM0NmVhMzNjMDllOTZiMGFlNjA5YWJjNmMwNWVl
-    Yjk2NTVjN2IzYjUxN2QzZTA3MjBmYmZjMzk2YWFlODViZmYyNjA=
+    YzZjOTA0ZWQ2OWUzMzk2YTYyODA1ZWIzYjBiZmU1MTc5Yjg4MTk0MDZjYWYz
+    YjZiZTZlZTBmYzQ0MWFlNjFlNzFiODVjOTc4YjAyOWRiODUwYWY4MjNiNmYy
+    ZDAyZDEwOTZjZjk3ODVmMWIyNmJkNWZiYmEyMzM4ZDNjYmU2MTI=
   data.tar.gz: !binary |-
-    YzdmYjMzMzlhMDZjZGZjNTVjZGUwNWRlMTk4N2EzYTlkZWFkMjU5ZWIzY2I1
-    ZGVlYjM1N2QwYzg3YTFiMDFkYzE3YzM0YTY2OGJmYTgzYTI3Njg0YjEzYmY2
-    YTQ5ZDQ2YjY3MWRjNjIzZmIyYmNlMDNkMDQ5OWM0MmNjNzhmNjQ=
+    MTdhN2RjYTRjMDIxMGJhNTM4YWM0YTViYzNjM2FjYmJmMjBmYjgwZGZjMDE0
+    MGNiZmM3YjI3OTJiNmU5OTAyZTZhNWVmOGFlNzQyZjMxNTYwZmIzMDY2NGU3
+    NTA4NTBkMGNiZjRhNmQzZjEyNjM4ZjMwNzFjYTI4YzgxZWFiYzg=

data/README.md

@@ -1,4 +1,5 @@
-[![Code Climate](https://codeclimate.com/github/dv/redis-semaphore.png)](https://codeclimate.com/github/dv/redis-semaphore)
+[![Code Climate](https://codeclimate.com/github/dv/redis-semaphore.svg?branch=master)](https://codeclimate.com/github/dv/redis-semaphore)
+[![Build Status](https://travis-ci.org/dv/redis-semaphore.svg?branch=master)](https://travis-ci.org/dv/redis-semaphore)
 
 redis-semaphore
 ===============
@@ -7,7 +8,7 @@ Implements a mutex and semaphore using Redis and the neat BLPOP command.
 
 The mutex and semaphore is blocking, not polling, and has a fair queue serving processes on a first-come, first-serve basis. It can also have an optional timeout after which a lock is unlocked automatically, to protect against dead clients.
 
-For more info see [Wikipedia](http://en.wikipedia.org/wiki/Semaphore_(programming\)).
+For more info see [Wikipedia](http://en.wikipedia.org/wiki/Semaphore_(programming)).
 
 Usage
 -----
@@ -15,7 +16,7 @@ Usage
 Create a mutex:
 
 ```ruby
-s = Redis::Semaphore.new(:semaphore_name, :connection => "localhost")
+s = Redis::Semaphore.new(:semaphore_name, :host => "localhost")
 s.lock do
   # We're now in a mutex protected area
   # No matter how many processes are running this program,
@@ -29,7 +30,7 @@ While our application is inside the code block given to ```s.lock```, other call
 You can also allow a set number of processes inside the semaphore-protected block, in case you have a well-defined number of resources available:
 
 ```ruby
-s = Redis::Semaphore.new(:semaphore_name, :resources => 5, :connection => "localhost")
+s = Redis::Semaphore.new(:semaphore_name, :resources => 5, :host => "localhost")
 s.lock do
   # Up to five processes at a time will be able to get inside this code
   # block simultaneously.
@@ -40,7 +41,7 @@ end
 You're not obligated to use code blocks, linear calls work just fine:
 
 ```ruby
-s = Redis::Semaphore.new(:semaphore_name, :connection => "localhost")
+s = Redis::Semaphore.new(:semaphore_name, :host => "localhost")
 s.lock
 work
 s.unlock  # Don't forget this, or the mutex will stay locked!
@@ -75,7 +76,7 @@ sem.available_count # also returns 1
 In the constructor you can pass in any arguments that you would pass to a regular Redis constructor. You can even pass in your custom Redis client:
 
 ```ruby
-r = Redis.new(:connection => "localhost", :db => 222)
+r = Redis.new(:host => "localhost", :db => 222)
 s = Redis::Semaphore.new(:another_name, :redis => r)
 #...
 ```
@@ -107,10 +108,10 @@ s = Redis::Semaphore.new(:stale_semaphore, :redis = r, :stale_client_timeout =>
 Or you could start a different thread or program that frequently checks for stale locks. This has the advantage of unblocking blocking calls to Semaphore#lock as well:
 
 ```ruby
-normal_sem = Redis::Semaphore.new(:semaphore, :connection => "localhost")
+normal_sem = Redis::Semaphore.new(:semaphore, :host => "localhost")
 
 Thread.new do
-  watchdog = Redis::Semaphore.new(:semaphore, :connection => "localhost", :stale_client_timeout => 5)
+  watchdog = Redis::Semaphore.new(:semaphore, :host => "localhost", :stale_client_timeout => 5)
 
   while(true) do
     watchdog.release_stale_locks!
@@ -175,6 +176,16 @@ s = Redis::Semaphore.new(:local_semaphore, :redis = r, :stale_client_timeout =>
 Redis servers earlier than version 2.6 don't support the TIME command. In that case we fall back to using the local time automatically.
 
 
+### Expiration
+
+```redis-semaphore``` supports an expiration option, which will call the **EXPIRE** Redis command on all related keys (except for `grabbed_keys`), to make sure that after a while all evidence of the semaphore will disappear and your Redis server will not be cluttered with unused keys. Pass in the expiration timeout in seconds:
+
+```ruby
+s = Redis::Semaphore.new(:local_semaphore, :redis = r, :expiration => 100)
+```
+
+This option should only be used if you know what you're doing. If you chose a wrong expiration timeout then the semaphore might disappear in the middle of a critical section. For most situations just using the `delete!` command should suffice to remove all semaphore keys from the server after you're done using the semaphore.
+
 Installation
 ------------
 
@@ -189,6 +200,10 @@ Testing
 Changelog
 ---------
 
+###0.2.4 January 11, 2015
+- Fix bug with TIME and redis-namespace (thanks sos4nt!).
+- Add expiration option (thanks jcalvert!).
+
 ###0.2.3 September 7, 2014
 - Block-based locking return the value of the block (thanks frobcode!).
 
@@ -237,7 +252,7 @@ Author
 Contributors
 ------------
 
-Thanks to these awesome peeps for their contributions:
+Thanks to these awesome people for their contributions:
 
 - [Rimas Silkaitis](https://github.com/neovintage)
 - [Tim Galeckas](https://github.com/timgaleckas)
@@ -248,3 +263,7 @@ Thanks to these awesome peeps for their contributions:
 - [presskey](https://github.com/presskey)
 - [Stephen Bussey](https://github.com/sb8244)
 - [frobcode](https://github.com/frobcode)
+- [Petteri Räty](https://github.com/betelgeuse)
+- [Stefan Schüßler](https://github.com/sos4nt)
+- [Jonathan Calvert](https://github.com/jcalvert)
+

data/lib/redis/semaphore.rb

@@ -2,19 +2,21 @@ require 'redis'
 
 class Redis
   class Semaphore
+    EXISTS_TOKEN = "1"
     API_VERSION = "1"
 
-    #stale_client_timeout is the threshold of time before we assume
-    #that something has gone terribly wrong with a client and we
-    #invalidate it's lock.
+    # stale_client_timeout is the threshold of time before we assume
+    # that something has gone terribly wrong with a client and we
+    # invalidate it's lock.
     # Default is nil for which we don't check for stale clients
     # Redis::Semaphore.new(:my_semaphore, :stale_client_timeout => 30, :redis => myRedis)
     # Redis::Semaphore.new(:my_semaphore, :redis => myRedis)
     # Redis::Semaphore.new(:my_semaphore, :resources => 1, :redis => myRedis)
-    # Redis::Semaphore.new(:my_semaphore, :connection => "", :port => "")
+    # Redis::Semaphore.new(:my_semaphore, :host => "", :port => "")
     # Redis::Semaphore.new(:my_semaphore, :path => "bla")
     def initialize(name, opts = {})
       @name = name
+      @expiration = opts.delete(:expiration)
       @resource_count = opts.delete(:resources) || 1
       @stale_client_timeout = opts.delete(:stale_client_timeout)
       @redis = opts.delete(:redis) || Redis.new(opts)
@@ -23,13 +25,19 @@ class Redis
     end
 
     def exists_or_create!
-      token = @redis.getset(exists_key, API_VERSION)
+      token = @redis.getset(exists_key, EXISTS_TOKEN)
 
       if token.nil?
         create!
-      elsif token != API_VERSION
-        raise "Semaphore exists but running as wrong version (version #{token} vs #{API_VERSION})."
       else
+        # Previous versions of redis-semaphore did not set `version_key`.
+        # Make sure it's set now, so we can use it in future versions.
+
+        if token == API_VERSION && @redis.get(version_key).nil?
+          @redis.set(version_key, API_VERSION)
+        end
+
+        set_expiration_if_necessary
         true
       end
     end
@@ -42,6 +50,7 @@ class Redis
       @redis.del(available_key)
       @redis.del(grabbed_key)
       @redis.del(exists_key)
+      @redis.del(version_key)
     end
 
     def lock(timeout = 0)
@@ -80,7 +89,7 @@ class Redis
         @tokens.each do |token|
           return true if locked?(token)
         end
-        
+
         false
       end
     end
@@ -127,6 +136,7 @@ class Redis
     end
 
   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)
@@ -150,10 +160,18 @@ class Redis
         @resource_count.times do |index|
           @redis.rpush(available_key, index)
         end
+        @redis.set(version_key, API_VERSION)
+        @redis.persist(exists_key)
 
-        # Persist key
-        @redis.del(exists_key)
-        @redis.set(exists_key, API_VERSION)
+        set_expiration_if_necessary
+      end
+    end
+
+    def set_expiration_if_necessary
+      if @expiration
+        [available_key, exists_key, version_key].each do |key|
+          @redis.expire(key, @expiration)
+        end
       end
     end
 
@@ -185,12 +203,16 @@ class Redis
       @grabbed_key ||= namespaced_key('GRABBED')
     end
 
+    def version_key
+      @version_key ||= namespaced_key('VERSION')
+    end
+
     def current_time
       if @use_local_time
         Time.now
       else
         begin
-          instant = @redis.time
+          instant = redis_namespace? ? @redis.redis.time : @redis.time
           Time.at(instant[0], instant[1])
         rescue
           @use_local_time = true

data/spec/semaphore_spec.rb

@@ -112,6 +112,29 @@ describe "redis" do
       end
       expect(block_value).to eq(lock_token)
     end
+
+    it "should disappear without a trace when calling `delete!`" do
+      original_key_size = @redis.keys.count
+
+      semaphore.exists_or_create!
+      semaphore.delete!
+
+      expect(@redis.keys.count).to eq(original_key_size)
+    end
+  end
+
+  describe "semaphore with expiration" do
+    let(:semaphore) { Redis::Semaphore.new(:my_semaphore, :redis => @redis, :expiration => 2) }
+    let(:multisem) { Redis::Semaphore.new(:my_semaphore_2, :resources => 2, :redis => @redis, :expiration => 2) }
+
+    it_behaves_like "a semaphore"
+
+    it "expires keys" do
+      original_key_size = @redis.keys.count
+      semaphore.exists_or_create!
+      sleep 3.0
+      expect(@redis.keys.count).to eq(original_key_size)
+    end
   end
 
   describe "semaphore without staleness checking" do
@@ -201,4 +224,23 @@ describe "redis" do
       expect(available_keys).to eq(grabbed_keys)
     end
   end
+
+  describe "version" do
+    context "with an existing versionless semaphore" do
+      let(:old_sem) { Redis::Semaphore.new(:my_semaphore, :redis => @redis) }
+      let(:semaphore) { Redis::Semaphore.new(:my_semaphore, :redis => @redis) }
+      let(:version_key) { old_sem.send(:version_key) }
+
+      before do
+        old_sem.exists_or_create!
+        @redis.del(version_key)
+      end
+
+      it "sets the version key" do
+        semaphore.exists_or_create!
+        expect(@redis.get(version_key)).not_to be_nil
+      end
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,11 +1,6 @@
 require 'rubygems'
-require 'bundler'
-Bundler.setup(:default, :test)
-Bundler.require(:default, :test)
-
-require 'rspec'
-require 'redis'
-require 'logger'
+require 'bundler/setup'
+Bundler.require(:development)
 
 $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-semaphore
 version: !ruby/object:Gem::Version
-  version: 0.2.3.1
+  version: 0.2.4
 platform: ruby
 authors:
 - David Verhasselt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-07 00:00:00.000000000 Z
+date: 2015-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,6 +24,62 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: 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
+  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
+  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.
 
 '