redis-em-mutex 0.1.0 → 0.1.1

data/lib/redis-em-mutex.rb

@@ -1,5 +1,5 @@
-class Redis
-  module EM
-    autoload :Mutex, 'redis/em-mutex'
-  end
-end
+class Redis
+  module EM
+    autoload :Mutex, 'redis/em-mutex'
+  end
+end

data/spec/redis-em-mutex-namespaces.rb

@@ -0,0 +1,113 @@
+$:.unshift "lib"
+require 'securerandom'
+require 'em-synchrony'
+require 'redis-em-mutex'
+
+describe Redis::EM::Mutex do
+
+  it "should have namespaced semaphores" do
+    described_class.ns = 'MutexTEST'
+    described_class.ns.should eq 'MutexTEST'
+    mutex = described_class.new(*@lock_names)
+    mutex.instance_variable_get(:'@ns_names').each_with_index.all? do |ns_name, index|
+      ns_name.should eq "MutexTEST:#{@lock_names[index]}"
+    end
+    described_class.ns = nil
+    described_class.ns.should be_nil
+    mutex = described_class.new(*@lock_names)
+    mutex.instance_variable_get(:'@ns_names').each_with_index.all? do |ns_name, index|
+      ns_name.should eq "#{@lock_names[index]}"
+    end
+    mutex = described_class.new(*@lock_names, ns: 'MutexLocalTEST')
+    mutex.instance_variable_get(:'@ns_names').each_with_index.all? do |ns_name, index|
+      ns_name.should eq "MutexLocalTEST:#{@lock_names[index]}"
+    end
+    ns = described_class::NS.new(:MutexCustomTEST)
+    mutex = ns.new(*@lock_names)
+    mutex.instance_variable_get(:'@ns_names').each_with_index.all? do |ns_name, index|
+      ns_name.should eq "MutexCustomTEST:#{@lock_names[index]}"
+    end
+  end
+
+  it "should lock and allow locking on the same semaphore name with different namespace" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.locked?.should be_true
+      mutex.owned?.should be_true
+      ns_mutex = described_class.lock(*@lock_names, ns: :MutexLocalTEST)
+      ns_mutex.locked?.should be_true
+      ns_mutex.owned?.should be_true
+      expect {
+        mutex.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      expect {
+        ns_mutex.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      mutex.unlock
+      mutex.locked?.should be_false
+      mutex.owned?.should be_false
+      ns_mutex.unlock
+      ns_mutex.locked?.should be_false
+      ns_mutex.owned?.should be_false
+    ensure
+      mutex.unlock if mutex
+      ns_mutex.unlock if ns_mutex
+    end
+  end
+
+  it "should lock and allow locking on different semaphore name with the same namespace" do
+    begin
+      ns = described_class::NS.new(:MutexCustomTEST)
+      mutex1 = ns.lock(@lock_names.first)
+      mutex1.locked?.should be_true
+      mutex1.owned?.should be_true
+      mutex2 = ns.lock(@lock_names.last)
+      mutex2.locked?.should be_true
+      mutex2.owned?.should be_true
+      expect {
+        mutex1.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      expect {
+        mutex2.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      mutex1.unlock
+      mutex1.locked?.should be_false
+      mutex1.owned?.should be_false
+      mutex2.unlock
+      mutex2.locked?.should be_false
+      mutex2.owned?.should be_false
+    ensure
+      mutex1.unlock if mutex1
+      mutex2.unlock if mutex2
+    end
+  end
+
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+        described_class.stop_watcher
+      rescue => e
+        described_class.stop_watcher(true)
+        raise e
+      ensure
+        ::EM.stop
+      end
+    end
+    @after_em_stop.call if @after_em_stop
+  end
+
+  before(:all) do
+    @redis_options = {}
+    described_class.setup @redis_options.merge(size: 11)
+    @lock_names = 10.times.map {
+      SecureRandom.random_bytes
+    }
+  end
+
+  after(:all) do
+    # @lock_names
+  end
+end

data/spec/redis-em-mutex-semaphores.rb

@@ -7,170 +7,168 @@ require 'redis-em-mutex'
 describe Redis::EM::Mutex do
 
   it "should lock and prevent locking on the same semaphore" do
-    begin
-      described_class.new(@lock_names.first).owned?.should be_false
-      mutex = described_class.lock(@lock_names.first)
-      mutex.names.should eq [@lock_names.first]
-      mutex.locked?.should be_true
-      mutex.owned?.should be_true
-      mutex.should be_an_instance_of described_class
-      described_class.new(@lock_names.first).try_lock.should be_false
-      expect {
-        mutex.lock
-      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.locked?.should be_false
-      mutex.owned?.should be_false
-      mutex.try_lock.should be_true
-    ensure
-      mutex.unlock if mutex
-    end
+    described_class.new(@lock_names.first).owned?.should be_false
+    mutex = described_class.lock(@lock_names.first)
+    mutex.names.should eq [@lock_names.first]
+    mutex.locked?.should be_true
+    mutex.owned?.should be_true
+    mutex.should be_an_instance_of described_class
+    described_class.new(@lock_names.first).try_lock.should be_false
+    expect {
+      mutex.lock
+    }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.locked?.should be_false
+    mutex.owned?.should be_false
+    mutex.try_lock.should be_true
+    mutex.unlock if mutex
   end
 
   it "should lock and prevent locking on the same multiple semaphores" do
-    begin
-      mutex = described_class.lock(*@lock_names)
-      mutex.names.should eq @lock_names
-      mutex.locked?.should be_true
-      mutex.owned?.should be_true
-      mutex.should be_an_instance_of described_class
-      described_class.new(*@lock_names).try_lock.should be_false
-      @lock_names.each do |name|
-        described_class.new(name).try_lock.should be_false
-      end
-      mutex.try_lock.should be_false
+    mutex = described_class.lock(*@lock_names)
+    mutex.names.should eq @lock_names
+    mutex.locked?.should be_true
+    mutex.owned?.should be_true
+    mutex.should be_an_instance_of described_class
+    described_class.new(*@lock_names).try_lock.should be_false
+    @lock_names.each do |name|
+      described_class.new(name).try_lock.should be_false
+    end
+    mutex.try_lock.should be_false
+    expect {
+      mutex.lock
+    }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+    @lock_names.each do |name|
       expect {
-        mutex.lock
+        described_class.new(name).lock
       }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
-      @lock_names.each do |name|
-        expect {
-          described_class.new(name).lock
-        }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
-      end
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.locked?.should be_false
-      mutex.owned?.should be_false
-      mutex.try_lock.should be_true
-    ensure
-      mutex.unlock if mutex
     end
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.locked?.should be_false
+    mutex.owned?.should be_false
+    mutex.try_lock.should be_true
+    mutex.unlock if mutex
   end
 
   it "should lock and prevent other fibers to lock on the same semaphore" do
-    begin
-      mutex = described_class.lock(@lock_names.first)
-      mutex.should be_an_instance_of described_class
-      mutex.owned?.should be_true
-      locked = true
-      ::EM::Synchrony.next_tick do
-        mutex.try_lock.should be false
+    mutex = described_class.lock(@lock_names.first)
+    mutex.should be_an_instance_of described_class
+    mutex.owned?.should be_true
+    locked = true
+    ::EM::Synchrony.next_tick do
+      begin
+        mutex.try_lock.should be_false
         mutex.owned?.should be_false
         start = Time.now
         mutex.synchronize do
-          (Time.now - start).should be_within(0.01).of(0.26)
-          locked.should be false
+          (Time.now - start).should be_within(0.015).of(0.26)
+          locked.should be_false
           locked = nil
         end
+      rescue Exception => e
+        @exception = e
       end
-      ::EM::Synchrony.sleep 0.25
-      locked = false
-      mutex.owned?.should be_true
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.owned?.should be_false
-      ::EM::Synchrony.sleep 0.1
-      locked.should be_nil
-    ensure
-      mutex.unlock if mutex
     end
+    ::EM::Synchrony.sleep 0.25
+    locked = false
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.owned?.should be_false
+    ::EM::Synchrony.sleep 0.2
+    locked.should be_nil
   end
 
   it "should lock and prevent other fibers to lock on the same multiple semaphores" do
-    begin
-      mutex = described_class.lock(*@lock_names)
-      mutex.should be_an_instance_of described_class
-      mutex.owned?.should be_true
-      locked = true
-      ::EM::Synchrony.next_tick do
-        locked.should be true
-        mutex.try_lock.should be false
+    mutex = described_class.lock(*@lock_names)
+    mutex.should be_an_instance_of described_class
+    mutex.owned?.should be_true
+    locked = true
+    ::EM::Synchrony.next_tick do
+      begin
+        locked.should be_true
+        mutex.try_lock.should be_false
         mutex.owned?.should be_false
         start = Time.now
         mutex.synchronize do
           mutex.owned?.should be_true
-          (Time.now - start).should be_within(0.01).of(0.26)
-          locked.should be false
+          (Time.now - start).should be_within(0.015).of(0.26)
+          locked.should be_false
         end
         mutex.owned?.should be_false
         ::EM::Synchrony.sleep 0.1
         start = Time.now
         ::EM::Synchrony::FiberIterator.new(@lock_names, @lock_names.length).each do |name|
-          locked.should be true
-          described_class.new(name).synchronize do
-            (Time.now - start).should be_within(0.01).of(0.26)
-            locked.should be_an_instance_of Fixnum
-            locked-= 1
+          begin
+            locked.should be_true
+            described_class.new(name).synchronize do
+              (Time.now - start).should be_within(0.015).of(0.26)
+              locked.should be_an_instance_of Fixnum
+              locked-= 1
+            end
+          rescue Exception => e
+            @exception = e
           end
         end
+      rescue Exception => e
+        @exception = e
       end
-      ::EM::Synchrony.sleep 0.25
-      locked = false
-      mutex.owned?.should be_true
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.owned?.should be_false
-      ::EM::Synchrony.sleep 0.1
-
-      locked = true
-      mutex.lock.should be true
-      ::EM::Synchrony.sleep 0.25
-      locked = 10
-      mutex.unlock.should be_an_instance_of described_class
-      ::EM::Synchrony.sleep 0.1
-      locked.should eq 0
-    ensure
-      mutex.unlock if mutex
     end
+    ::EM::Synchrony.sleep 0.25
+    locked = false
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.owned?.should be_false
+    ::EM::Synchrony.sleep 0.1
+
+    locked = true
+    mutex.lock.should be_true
+    ::EM::Synchrony.sleep 0.25
+    locked = 10
+    mutex.unlock.should be_an_instance_of described_class
+    ::EM::Synchrony.sleep 0.1
+    locked.should eq 0
   end
 
   it "should lock and prevent other fibers to lock on the same semaphore with block timeout" do
-    begin
-      mutex = described_class.lock(*@lock_names)
-      mutex.should be_an_instance_of described_class
-      mutex.owned?.should be_true
-      locked = true
-      ::EM::Synchrony.next_tick do
+    mutex = described_class.lock(*@lock_names)
+    mutex.should be_an_instance_of described_class
+    mutex.owned?.should be_true
+    locked = true
+    ::EM::Synchrony.next_tick do
+      begin
         start = Time.now
-        mutex.lock(0.25).should be false
+        mutex.lock(0.25).should be_false
         mutex.owned?.should be_false
         (Time.now - start).should be_within(0.01).of(0.26)
-        locked.should be true
+        locked.should be_true
         locked = nil
+      rescue Exception => e
+        @exception = e
       end
-      ::EM::Synchrony.sleep 0.26
-      locked.should be_nil
-      locked = false
-      mutex.locked?.should be_true
-      mutex.owned?.should be_true
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.locked?.should be_false
-      mutex.owned?.should be_false
-    ensure
-      mutex.unlock if mutex
     end
+    ::EM::Synchrony.sleep 0.26
+    locked.should be_nil
+    locked = false
+    mutex.locked?.should be_true
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.locked?.should be_false
+    mutex.owned?.should be_false
   end
 
   it "should lock and expire while other fiber lock on the same semaphore with block timeout" do
-    begin
-      mutex = described_class.lock(*@lock_names, expire: 0.2499999)
-      mutex.expire_timeout.should eq 0.2499999
-      mutex.should be_an_instance_of described_class
-      mutex.owned?.should be_true
-      locked = true
-      ::EM::Synchrony.next_tick do
+    mutex = described_class.lock(*@lock_names, expire: 0.2499999)
+    mutex.expire_timeout.should eq 0.2499999
+    mutex.should be_an_instance_of described_class
+    mutex.owned?.should be_true
+    locked = true
+    ::EM::Synchrony.next_tick do
+      begin
         mutex.owned?.should be_false
         start = Time.now
-        mutex.lock(0.25).should be true
+        mutex.lock(0.25).should be_true
         (Time.now - start).should be_within(0.011).of(0.26)
-        locked.should be true
+        locked.should be_true
         locked = nil
         mutex.locked?.should be_true
         mutex.owned?.should be_true
@@ -179,52 +177,52 @@ describe Redis::EM::Mutex do
         mutex.unlock.should be_an_instance_of described_class
         mutex.owned?.should be_false
         mutex.locked?.should be_false
+      rescue Exception => e
+        @exception = e
       end
-      ::EM::Synchrony.sleep 0.26
-      locked.should be_nil
-      locked = false
-      mutex.locked?.should be_true
-      mutex.owned?.should be_false
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.locked?.should be_true
-      mutex.owned?.should be_false
-      ::EM::Synchrony.sleep 0.2
-    ensure
-      mutex.unlock if mutex
     end
+    ::EM::Synchrony.sleep 0.26
+    locked.should be_nil
+    locked = false
+    mutex.locked?.should be_true
+    mutex.owned?.should be_false
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.locked?.should be_true
+    mutex.owned?.should be_false
+    ::EM::Synchrony.sleep 0.5
   end
 
   it "should lock and prevent (with refresh) other fibers to lock on the same semaphore with block timeout" do
-    begin
-      mutex = described_class.lock(*@lock_names, expire: 0.11)
-      mutex.should be_an_instance_of described_class
-      mutex.owned?.should be_true
-      locked = true
-      ::EM::Synchrony.next_tick do
+    mutex = described_class.lock(*@lock_names, expire: 0.11)
+    mutex.should be_an_instance_of described_class
+    mutex.owned?.should be_true
+    locked = true
+    ::EM::Synchrony.next_tick do
+      begin
         start = Time.now
-        mutex.lock(0.3).should be false
+        mutex.lock(0.3).should be_false
         mutex.owned?.should be_false
         (Time.now - start).should be_within(0.01).of(0.31)
-        locked.should be true
+        locked.should be_true
         locked = nil
+      rescue Exception => e
+        @exception = e
       end
-      ::EM::Synchrony.sleep 0.08
-      mutex.owned?.should be_true
-      mutex.refresh
-      ::EM::Synchrony.sleep 0.08
-      mutex.owned?.should be_true
-      mutex.refresh(0.5)
-      ::EM::Synchrony.sleep 0.15
-      locked.should be_nil
-      locked = false
-      mutex.locked?.should be_true
-      mutex.owned?.should be_true
-      mutex.unlock.should be_an_instance_of described_class
-      mutex.locked?.should be_false
-      mutex.owned?.should be_false
-    ensure
-      mutex.unlock if mutex
     end
+    ::EM::Synchrony.sleep 0.08
+    mutex.owned?.should be_true
+    mutex.refresh
+    ::EM::Synchrony.sleep 0.08
+    mutex.owned?.should be_true
+    mutex.refresh(0.5)
+    ::EM::Synchrony.sleep 0.15
+    locked.should be_nil
+    locked = false
+    mutex.locked?.should be_true
+    mutex.owned?.should be_true
+    mutex.unlock.should be_an_instance_of described_class
+    mutex.locked?.should be_false
+    mutex.owned?.should be_false
   end
 
   it "should lock some resource and play with it safely" do
@@ -232,20 +230,24 @@ describe Redis::EM::Mutex do
     play_name = SecureRandom.random_bytes
     result = []
     ::EM::Synchrony::FiberIterator.new((0..9).to_a, 10).each do |i|
-      was_locked = false
-      redis = Redis.new @redis_options
-      mutex.owned?.should be_false
-      mutex.synchronize do
-        mutex.owned?.should be_true
-        was_locked = true
-        redis.setnx(play_name, i).should be_true
-        ::EM::Synchrony.sleep 0.1
-        redis.get(play_name).should eq i.to_s
-        redis.del(play_name).should eq 1
+      begin
+        was_locked = false
+        redis = Redis.new @redis_options
+        mutex.owned?.should be_false
+        mutex.synchronize do
+          mutex.owned?.should be_true
+          was_locked = true
+          redis.setnx(play_name, i).should be_true
+          ::EM::Synchrony.sleep 0.1
+          redis.get(play_name).should eq i.to_s
+          redis.del(play_name).should eq 1
+        end
+        was_locked.should be_true
+        mutex.owned?.should be_false
+        result << i
+      rescue Exception => e
+        @exception = e
       end
-      was_locked.should be_true
-      mutex.owned?.should be_false
-      result << i
     end
     mutex.locked?.should be_false
     result.sort.should eq (0..9).to_a
@@ -256,14 +258,18 @@ describe Redis::EM::Mutex do
     mutex.should be_an_instance_of described_class
     time = nil
     EM::Synchrony.next_tick do
-      time.should be_nil
-      was_locked = false
-      mutex.synchronize do
-        time.should be_an_instance_of Time
-        (Time.now - time).should be < 0.0009
-        was_locked = true
+      begin
+        time.should be_nil
+        was_locked = false
+        mutex.synchronize do
+          time.should be_an_instance_of Time
+          (Time.now - time).should be < 0.0009
+          was_locked = true
+        end
+        was_locked.should be_true
+      rescue Exception => e
+        @exception = e
       end
-      was_locked.should be_true
     end
     EM::Synchrony.sleep 0.1
     mutex.owned?.should be_true
@@ -312,11 +318,16 @@ describe Redis::EM::Mutex do
 
   around(:each) do |testcase|
     @after_em_stop = nil
+    @exception = nil
     ::EM.synchrony do
       begin
         testcase.call
-      ensure
+        raise @exception if @exception
         described_class.stop_watcher(false)
+      rescue => e
+        described_class.stop_watcher(true)
+        raise e
+      ensure
         ::EM.stop
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-em-mutex
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &204598440 !ruby/object:Gem::Requirement
+  requirement: &254270740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *204598440
+  version_requirements: *254270740
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &204597980 !ruby/object:Gem::Requirement
+  requirement: &254270280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.4.5
   type: :runtime
   prerelease: false
-  version_requirements: *204597980
+  version_requirements: *254270280
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &204597520 !ruby/object:Gem::Requirement
+  requirement: &254269820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: 0.12.10
   type: :runtime
   prerelease: false
-  version_requirements: *204597520
+  version_requirements: *254269820
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &204597060 !ruby/object:Gem::Requirement
+  requirement: &254269360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *204597060
+  version_requirements: *254269360
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &204596600 !ruby/object:Gem::Requirement
+  requirement: &254268900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: 1.0.0.beta.1
   type: :development
   prerelease: false
-  version_requirements: *204596600
+  version_requirements: *254268900
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &204596140 !ruby/object:Gem::Requirement
+  requirement: &254268440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *204596140
+  version_requirements: *254268440
 description: Cross server-process-fiber EventMachine + Redis based semaphore with
   many features
 email: rafal@yeondir.com
@@ -85,12 +85,14 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
+- HISTORY.rdoc
 - README.rdoc
 - Rakefile
 - lib/redis-em-mutex.rb
 - lib/redis/em-mutex.rb
 - redis-em-mutex.gemspec
 - spec/redis-em-mutex-features.rb
+- spec/redis-em-mutex-namespaces.rb
 - spec/redis-em-mutex-semaphores.rb
 homepage: http://github.com/royaltm/redis-em-mutex
 licenses: []
@@ -122,5 +124,6 @@ signing_key:
 specification_version: 3
 summary: Cross server-process-fiber EventMachine + Redis based semaphore
 test_files:
+- spec/redis-em-mutex-namespaces.rb
 - spec/redis-em-mutex-semaphores.rb
 - spec/redis-em-mutex-features.rb