redis-em-mutex 0.1.2 → 0.2.0

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

@@ -0,0 +1,162 @@
+$:.unshift "lib"
+require 'securerandom'
+require 'em-synchrony'
+require 'em-synchrony/thread'
+require 'redis-em-mutex'
+
+describe Redis::EM::Mutex do
+
+  it "should lock and sleep forever until woken up" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.owned?.should be true
+      fiber = Fiber.current
+      start = Time.now
+      ::EM.add_timer(0.25) do
+        mutex.wakeup(fiber)
+      end
+      mutex.sleep.should be_within(0.01).of(0.25)
+      (Time.now - start).should be_within(0.01).of(0.25)
+      mutex.owned?.should be true
+      mutex.unlock!.should be_true
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should raise MutexError on sleep if unlocked" do
+    mutex = described_class.new(*@lock_names)
+    expect {
+      mutex.sleep
+    }.to raise_error(Redis::EM::Mutex::MutexError, /can't sleep #{described_class} wasn't locked/)
+  end
+
+  it "should lock and sleep with timeout" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.owned?.should be true
+      start = Time.now
+      mutex.sleep(0.25).should be_within(0.01).of(0.25)
+      (Time.now - start).should be_within(0.01).of(0.25)
+      mutex.owned?.should be true
+      mutex.unlock!.should be_true
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and sleep with timeout but woken up in the middle of a sleep" do
+    begin
+      mutex = described_class.lock(*@lock_names)
+      mutex.owned?.should be true
+      fiber = Fiber.current
+      start = Time.now
+      ::EM.add_timer(0.15) do
+        mutex.wakeup(fiber)
+      end
+      mutex.sleep(0.25).should be_within(0.001).of(0.15)
+      (Time.now - start).should be_within(0.001).of(0.15)
+      mutex.owned?.should be true
+      mutex.unlock!.should be_true
+    ensure
+      mutex.unlock if mutex
+    end
+  end
+
+  it "should lock and sleep and raise MutexTimeout on wakeup" do
+    begin
+      mutex = described_class.lock(*@lock_names, block: 0)
+      mutex.owned?.should be true
+      fiber = Fiber.current
+      ::EM::Synchrony.next_tick do
+        begin
+          mutex.owned?.should be false
+          mutex.lock.should be true
+          mutex.owned?.should be true
+          mutex.wakeup(fiber)
+          ::EM::Synchrony.sleep(0.2)
+          mutex.unlock!.should be_true
+        rescue Exception => e
+          @exception = e
+          mutex.unlock
+        end
+      end
+      start = Time.now
+      expect {
+        mutex.sleep
+      }.to raise_error(Redis::EM::Mutex::MutexTimeout)
+      (Time.now - start).should be_within(0.002).of(0.003)
+      mutex.owned?.should be false
+      mutex.unlock!.should be false
+      mutex.block_timeout = nil
+      start = Time.now
+      mutex.lock.should be true
+      (Time.now - start).should be_within(0.01).of(0.2)
+      mutex.owned?.should be true
+      mutex.unlock!.should be_true
+    rescue Exception => e
+      ::EM::Synchrony.sleep(0.3)
+      raise e
+    ensure
+      mutex.unlock
+    end
+  end
+
+  it "should work with EM::Synchrony::Thread::ConditionVariable" do
+    mutex = described_class.new(*@lock_names)
+    resource = ::EM::Synchrony::Thread::ConditionVariable.new
+    signal = nil
+    fiber = Fiber.current
+    ::EM::Synchrony.next_tick do
+      mutex.synchronize {
+        resource.wait(mutex)
+        fiber.resume Time.now
+      }
+    end
+    ::EM::Synchrony.next_tick do
+      mutex.synchronize {
+        ::EM::Synchrony.sleep(0.2)
+        resource.signal
+        signal = Time.now
+      }
+    end
+    start = Time.now
+    now = Fiber.yield
+    (now - signal).should be_within(0.001).of(0.001)
+    (now - start).should be_within(0.01).of(0.2)
+    mutex.synchronize do
+      signal = nil
+    end
+    signal.should be_nil
+  end
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    @exception = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+        raise @exception if @exception
+        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 = {:driver => :synchrony}
+    described_class.setup @redis_options.merge(size: 4)
+    @lock_names = 2.times.map {
+      SecureRandom.random_bytes
+    }
+  end
+
+  after(:all) do
+    # @lock_names
+  end
+end

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

@@ -32,11 +32,11 @@ describe Redis::EM::Mutex do
   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
+      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
+      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/)
@@ -44,11 +44,11 @@ describe Redis::EM::Mutex do
         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
+      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
+      ns_mutex.locked?.should be false
+      ns_mutex.owned?.should be false
     ensure
       mutex.unlock if mutex
       ns_mutex.unlock if ns_mutex
@@ -59,11 +59,11 @@ describe Redis::EM::Mutex do
     begin
       ns = described_class::NS.new(:MutexCustomTEST)
       mutex1 = ns.lock(@lock_names.first)
-      mutex1.locked?.should be_true
-      mutex1.owned?.should be_true
+      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
+      mutex2.locked?.should be true
+      mutex2.owned?.should be true
       expect {
         mutex1.lock
       }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
@@ -71,11 +71,11 @@ describe Redis::EM::Mutex do
         mutex2.lock
       }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
       mutex1.unlock
-      mutex1.locked?.should be_false
-      mutex1.owned?.should be_false
+      mutex1.locked?.should be false
+      mutex1.owned?.should be false
       mutex2.unlock
-      mutex2.locked?.should be_false
-      mutex2.owned?.should be_false
+      mutex2.locked?.should be false
+      mutex2.owned?.should be false
     ensure
       mutex1.unlock if mutex1
       mutex2.unlock if mutex2

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

@@ -0,0 +1,156 @@
+$:.unshift "lib"
+require 'securerandom'
+require 'em-synchrony'
+require 'em-synchrony/fiber_iterator'
+require 'redis-em-mutex'
+
+describe Redis::EM::Mutex do
+
+  it "should share a custom owner lock between fibers" do
+    begin
+      mutex = described_class.lock(*@lock_names, owner: 'my')
+      mutex.should be_an_instance_of described_class
+      mutex.names.should eq @lock_names
+      mutex.locked?.should be true
+      mutex.owned?.should be true
+      expect {
+        mutex.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      fiber = Fiber.current
+      ::EM::Synchrony.next_tick do
+        begin
+          mutex.try_lock.should be false
+          mutex.locked?.should be true
+          mutex.owned?.should be true
+          expect {
+            mutex.lock
+          }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+          mutex.refresh.should be true
+        rescue Exception => e
+          @exception = e
+        ensure
+          ::EM.next_tick { fiber.resume }
+        end
+      end
+      Fiber.yield
+      mutex.locked?.should be true
+      mutex.owned?.should be true
+      mutex.unlock.should be_an_instance_of described_class
+      ::EM::Synchrony.next_tick do
+        begin
+          mutex.locked?.should be false
+          mutex.owned?.should be false
+          mutex.lock.should be true
+          mutex.locked?.should be true
+          mutex.owned?.should be true
+          expect {
+            mutex.lock
+          }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+        rescue Exception => e
+          @exception = e
+        ensure
+          ::EM.next_tick { fiber.resume }
+        end
+      end
+      Fiber.yield
+      mutex.locked?.should be true
+      mutex.owned?.should be true
+      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
+  end
+
+  it "should share custom owner locks concurrently between group of fibers" do
+    begin
+      mutex1 = described_class.new(*@lock_names, owner: 'my1', block: 0)
+      mutex2 = described_class.new(*@lock_names, owner: 'my2', block: 0)
+      [mutex1, mutex2].each do |mutex|
+        mutex.should be_an_instance_of described_class
+        mutex.names.should eq @lock_names
+        mutex.locked?.should be false
+        mutex.owned?.should be false
+      end
+      mutex1.lock.should be true
+      mutex2.lock.should be false
+      mutex1.locked?.should be true
+      mutex1.owned?.should be true
+      mutex2.locked?.should be true
+      mutex2.owned?.should be false
+      expect {
+        mutex1.lock
+      }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+      fiber = Fiber.current
+      ::EM::Synchrony.next_tick do
+        begin
+          mutex1.locked?.should be true
+          mutex1.owned?.should be true
+          mutex2.locked?.should be true
+          mutex2.owned?.should be false
+          expect {
+            mutex1.lock
+          }.to raise_error(Redis::EM::Mutex::MutexError, /deadlock; recursive locking/)
+          mutex2.lock.should be false
+          mutex1.refresh.should be true
+          mutex2.refresh.should be false
+          mutex2.block_timeout = nil
+          ::EM.next_tick { fiber.resume }
+          start = Time.now
+          mutex2.lock.should be true
+          (Time.now - start).should be_within(0.01).of(0.5)
+        rescue Exception => e
+          @exception = e
+        ensure
+          ::EM.next_tick { fiber.resume }
+        end
+      end
+      Fiber.yield
+      EM::Synchrony.sleep 0.5
+      mutex1.refresh.should be true
+      mutex2.refresh.should be false
+      mutex1.unlock.should be_an_instance_of described_class
+      Fiber.yield
+      mutex1.refresh.should be false
+      mutex2.refresh.should be true
+    ensure
+      mutex1.unlock if mutex1
+      mutex2.unlock if mutex2
+    end
+  end
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    @exception = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+        raise @exception if @exception
+        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 = {:driver => :synchrony}
+    described_class.setup @redis_options.merge(size: 11)
+    @lock_names = 10.times.map {
+      SecureRandom.random_bytes
+    }
+  end
+
+  after(:all) do
+    # @lock_names
+  end
+end