redis-em-mutex 0.2.1 → 0.2.2

data/HISTORY.rdoc

@@ -1,3 +1,10 @@
+0.2.2
+- fixed: uuid must be set only once
+- fixed: forking process or setup before reactor is running would hang
+  current fiber forever on first failed lock
+- added: new setup option :redis_factory
+- fixed: doc format errors
+
 0.2.1
 - fixed: sleep
 - fixed: possible deadlock after #unlock! with multiple names

data/{README.rdoc → README.md}

@@ -1,14 +1,17 @@
-= redis-em-mutex
+redis-em-mutex
+==============
 
-Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
+Author: Rafał Michalski  (mailto:rafal@yeondir.com)
 
 * http://github.com/royaltm/redis-em-mutex
 
-== DESCRIPTION
+DESCRIPTION
+-----------
 
-*redis-em-mutex* is the cross server-process-fiber EventMachine + Redis based semaphore.
+__redis-em-mutex__ is the cross server-process-fiber EventMachine + Redis based semaphore.
 
-== FEATURES
+FEATURES
+--------
 
 * only for EventMachine
 * no CPU-intensive sleep/polling while waiting for lock to become available
@@ -24,78 +27,90 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 * compatible with Synchrony::Thread::ConditionVariable
 * extendable (beyond fibers) mutex ownership
 
-== BUGS/LIMITATIONS
+BUGS/LIMITATIONS
+----------------
 
 * only for EventMachine
 * NOT thread-safe
 * locking order between concurrent processes is undetermined (no FIFO)
 * it's not nifty, rather somewhat complicated
 
-== REQUIREMENTS
+REQUIREMENTS
+------------
 
-* ruby >= 1.9 (tested: 1.9.3-p194, 1.9.2-p320, 1.9.1-p378)
+* ruby >= 1.9 (tested: ruby 1.9.3p374, 1.9.3-p194, 1.9.2-p320, 1.9.1-p378)
 * http://github.com/redis/redis-rb ~> 3.0.1
 * http://rubyeventmachine.com ~> 1.0.0
 * (optional) http://github.com/igrigorik/em-synchrony
 
-== INSTALL
+INSTALL
+-------
 
-  $ [sudo] gem install redis-em-mutex
+```
+$ [sudo] gem install redis-em-mutex
+```
 
-==== Gemfile
+#### Gemfile
 
-  gem "redis-em-mutex", "~> 0.2.1"
+```ruby
+gem "redis-em-mutex", "~> 0.2.2"
+```
 
-==== Github
+#### Github
 
-  git clone git://github.com/royaltm/redis-em-mutex.git
+```
+git clone git://github.com/royaltm/redis-em-mutex.git
+```
 
-== USAGE
+USAGE
+-----
 
-  require 'em-synchrony'
-  require 'em-redis-mutex'
+```ruby
+    require 'em-synchrony'
+    require 'redis-em-mutex'
 
-  Redis::EM::Mutex.setup(size: 10, url: 'redis:///1', expire: 600)
+    Redis::EM::Mutex.setup(size: 10, url: 'redis:///1', expire: 600)
 
-  # or
+    # or
 
-  Redis::EM::Mutex.setup do |opts|
-    opts.size = 10
-    opts.url = 'redis:///1'
-    ...
-  end
+    Redis::EM::Mutex.setup do |opts|
+      opts.size = 10
+      opts.url = 'redis:///1'
+    end
 
 
-  EM.synchrony do
-    Redis::EM::Mutex.synchronize('resource.lock') do
-      ... do something with resource
-    end
+    EM.synchrony do
+      Redis::EM::Mutex.synchronize('resource.lock') do
+        # ... do something with resource
+      end
 
-    # or 
+      # or 
 
-    mutex = Redis::EM::Mutex.new('resource.lock')
-    mutex.synchronize do
-      ... do something with resource
-    end
+      mutex = Redis::EM::Mutex.new('resource.lock')
+      mutex.synchronize do
+        # ... do something with resource
+      end
 
-    # or
+      # or
 
-    begin
-      mutex.lock
-      ... do something with resource
-    ensure
-      mutex.unlock
-    end
+      begin
+        mutex.lock
+        # ... do something with resource
+      ensure
+        mutex.unlock
+      end
 
-    ...
+      # ...
 
-    Redis::EM::Mutex.stop_watcher
-    EM.stop
-  end
+      Redis::EM::Mutex.stop_watcher
+      EM.stop
+    end
+```
 
-=== Namespaces
+### Namespaces
 
-  Redis::EM::Mutex.setup(ns: 'my_namespace', ....)
+```ruby
+  Redis::EM::Mutex.setup(ns: 'my_namespace')
 
   # or multiple namespaces:
 
@@ -103,35 +118,41 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 
   EM.synchrony do
     ns.synchronize('foo') do
-      .... do something with foo
+      # .... do something with foo
     end
-    ...
+
+    # ...
     EM.stop
   end
+```
 
-=== Multi-locks
+### Multi-locks
 
+```ruby
   EM.synchrony do
     Redis::EM::Mutex.synchronize('foo', 'bar', 'baz') do
-      .... do something with foo, bar and baz
+      # .... do something with foo, bar and baz
     end
-    ...
+
+    # ...
     EM.stop
   end
+```
 
-=== Locking options
+### Locking options
 
+```ruby
   EM.synchrony do
     begin
       Redis::EM::Mutex.synchronize('foo', 'bar', block: 0.25) do
-        .... do something with foo and bar
+        # .... do something with foo and bar
       end
     rescue Redis::EM::Mutex::MutexTimeout
-      ... locking timed out
+      # ... locking timed out
     end
 
     Redis::EM::Mutex.synchronize('foo', 'bar', expire: 60) do |mutex|
-      .... do something with foo and bar in less than 60 seconds
+      # .... do something with foo and bar in less than 60 seconds
       if mutex.refresh(120)
         # now we have additional 120 seconds until lock expires
       else
@@ -139,23 +160,26 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
       end
     end
 
-    ...
+    # ...
     EM.stop
   end
+```
 
-=== Macro-style definition
+### Macro-style definition
 
 Borrowed from http://github.com/kenn/redis-mutex.
 Redis::EM::Mutex::Macro is a mixin which protects selected instance methods of a class with a mutex.
 The locking scope will be Mutex global namespace + class name + method name.
 
+```ruby
   class TheClass
     include Redis::EM::Mutex::Macro
   
     auto_mutex
     def critical_run
-      ... do some critical stuff
-      ....only one fiber in one process on one machine is executing this instance method of any instance of defined class
+      # ... do some critical stuff
+      # ....only one fiber in one process on one machine is executing
+      #     this instance method of any instance of defined class
     end
 
     auto_mutex expire: 100, ns: '**TheClass**'
@@ -163,39 +187,41 @@ The locking scope will be Mutex global namespace + class name + method name.
   
     auto_mutex # start and stop will be protected
     def start
-      ...
+      # ...
     end
 
     def stop
-      ...
+      # ...
     end
 
     no_auto_mutex
     def some_unprotected_method
-      ...
+      # ...
     end
 
     auto_mutex :run_long, expire: 100000, block: 10, on_timeout: :cant_run
     def run_long
-      ...
+      # ...
     end
 
     def cant_run
-      ...
+      # ...
     end
 
     def foo
-      ...
+      # ...
     end
     auto_mutex :foo, block: 0, on_timeout: proc { puts 'bar!' }
 
   end
+```
 
-=== ConditionVariable
+### ConditionVariable
 
 Redis::EM::Mutex may be used with EventMachine::Synchrony::Thread::ConditionVariable
 in place of EventMachine::Synchrony::Thread::Mutex.
 
+```ruby
   mutex = Redis::EM::Mutex.new('resource')
   resource = EM::Synchrony::Thread::ConditionVariable.new
   EM::Synchrony.next_tick do
@@ -211,10 +237,11 @@ in place of EventMachine::Synchrony::Thread::Mutex.
       resource.signal
     }
   end
+```
 
-=== Advanced
+### Advanced
 
-==== Customized owner
+#### Customized owner
 
 In some cases you might want to extend the ownership of a locked semaphore beyond the current fiber.
 That is to be able to "share" a locked semaphore between group of fibers associated with some external resource.
@@ -234,6 +261,7 @@ This way we make sure that any other connection from the same ip address made to
 will have different ownership defined. At the same time all the fibers working with that Connection instance
 can access mutex's #refresh and #unlock methods concurrently.
 
+```ruby
   module MutexedConnection
     def post_init
       @buffer = ""
@@ -274,13 +302,16 @@ can access mutex's #refresh and #unlock methods concurrently.
     Redis::EM::Mutex.setup(size: 10, url: 'redis:///1', expire: 600)
     EM.start_server "0.0.0.0", 6969, MutexedConnection
   }
+```
 
-==== Forking live
+#### Forking live
 
 You may safely fork process while running event reactor and having locked semaphores.
 The locked semaphores in newly forked process will become unlocked while
 their locked status in parent process will be preserved.
 
+
+```ruby
   mutex = Redis::EM::Mutex.new('resource1', 'resource2', expire: 60)
 
   EM.synchrony do
@@ -294,9 +325,10 @@ their locked status in parent process will be preserved.
           mutex.locked? # true
           mutex.owned?  # true
 
-          ....
+          # ...
         end
-        ...
+
+        # ...
         Redis::EM::Mutex.stop_watcher
         EM.stop
       end.resume
@@ -308,11 +340,33 @@ their locked status in parent process will be preserved.
     mutex.unlock
     mutex.owned?  # false
 
-    ...
+    # ...
     Redis::EM::Mutex.stop_watcher
     EM.stop
   end
+```
+
+#### Redis factory
+
+Want to use some non-standard redis options or customized client for semaphore watcher and/or redis pool?
+Use `:redis_factory` option then.
+
+```ruby
+  require 'redis-sentinel'
+
+  Redis::EM::Mutex.setup do |opts|
+    opts.size = 10
+    opts.password = 'password'
+    opts.db = 11
+    opts.redis_factory = proc do |options|
+      Redis.new options.merge(
+        master_name: "my_master",
+        sentinels: [{host: "redis1", port: 6379}, {host: "redis2", port: 6380}])
+    end
+  end
+```
 
-== LICENCE
+LICENCE
+-------
 
 The MIT License - Copyright (c) 2012 Rafał Michalski

data/Rakefile

@@ -33,5 +33,5 @@ end
 
 desc "Documentation"
 task :doc do
-  sh "rdoc --encoding=UTF-8 --title=#$gem_name --main=README.rdoc README.rdoc lib/*.rb lib/*/*.rb"
+  sh "yardoc"
 end

data/lib/redis/em-mutex/version.rb

@@ -1,7 +1,7 @@
 class Redis
   module EM
     class Mutex
-      VERSION = '0.2.1'
+      VERSION = '0.2.2'
     end
   end
 end

data/lib/redis/em-mutex.rb

@@ -32,19 +32,20 @@ class Redis
       include Errors
       extend Errors
 
-      @@connection_pool_class = nil
-      @@connection_retry_max = 10
-      @@default_expire = 3600*24
-      AUTO_NAME_SEED = '__@'
       SIGNAL_QUEUE_CHANNEL = "::#{self.name}::"
+      AUTO_NAME_SEED = '__@'
+      DEFAULT_RECONNECT_MAX_RETRIES = 10
+      @@default_expire = 3600*24
       @@name_index = AUTO_NAME_SEED
       @@redis_pool = nil
-      @@redis_watcher = nil
       @@watching = false
-      @@watcher_subscribed = false
       @@signal_queue = Hash.new {|h,k| h[k] = []}
       @@ns = nil
-      @@uuid = nil
+      @@uuid ||= if SecureRandom.respond_to?(:uuid)
+        SecureRandom.uuid
+      else
+        SecureRandom.base64(24)
+      end
 
       attr_reader :names, :ns, :block_timeout
       alias_method :namespace, :ns
@@ -264,10 +265,10 @@ class Redis
           ::EM.next_tick { fiber.resume if fiber } if fiber
         end
         begin
+          Mutex.start_watcher unless watching?
           queues = names.map {|n| @@signal_queue[n] << handler }
           ident_match = owner_ident
           until try_lock
-            Mutex.start_watcher unless watching?
             start_time = Time.now.to_f
             expire_time = nil
             @@redis_pool.execute(false) do |r|
@@ -382,10 +383,17 @@ class Redis
       def self.watching?; @@watching == $$; end
 
       class << self
+        attr_reader :reconnect_max_retries
+        def reconnect_forever?
+          @reconnect_max_retries < 0
+        end
+        def reconnect_max_retries=(max)
+          @reconnect_max_retries = max == :forever ? -1 : max.to_i
+        end
         def ns; @@ns; end
         def ns=(namespace); @@ns = namespace; end
         alias_method :namespace, :ns
-        alias_method :'namespace=', :'ns='
+        alias_method :namespace=, :ns=
 
         # Default value of expiration timeout in seconds.
         def default_expire; @@default_expire; end
@@ -405,18 +413,19 @@ class Redis
         # global options:
         #
         # - :connection_pool_class - default is ::EM::Synchrony::ConnectionPool
+        # - :redis_factory - default is proc {|opts| Redis.new opts }
         # - :expire   - sets global Mutex.default_expire 
         # - :ns       - sets global Mutex.namespace
         # - :reconnect_max - maximum num. of attempts to re-establish
         #   connection to redis server;
         #   default is 10; set to 0 to disable re-connecting;
-        #   set to -1 to attempt forever
+        #   set to -1 or :forever to attempt forever
         #
         # redis connection options:
         #
         # - :size     - redis connection pool size
         #
-        # passed directly to Redis.new:
+        # passed directly to redis_factory:
         #
         # - :url      - redis server url
         #
@@ -434,10 +443,10 @@ class Redis
         # - :redis    - initialized ConnectionPool of Redis clients.
         def setup(opts = {})
           stop_watcher
+          @watcher_subscribed = nil
           opts = OpenStruct.new(opts)
           yield opts if block_given?
-          @@connection_pool_class = opts.connection_pool_class if opts.connection_pool_class.kind_of?(Class)
-          @redis_options = redis_options = {:driver => :synchrony}
+          redis_options = {:driver => :synchrony}
           redis_updater = proc do |redis|
             redis_options.update({
               :scheme => redis.scheme,
@@ -454,33 +463,37 @@ class Redis
             redis_options[:url] = opts.url
           end
           redis_updater.call opts
-          namespace = opts.ns
           pool_size = (opts.size.to_i.nonzero? || 1).abs
           self.default_expire = opts.expire if opts.expire
-          @@connection_retry_max = opts.reconnect_max.to_i if opts.reconnect_max
-          @@ns = namespace if namespace
-          @@uuid = if SecureRandom.respond_to?(:uuid)
-            SecureRandom.uuid
-          else
-            SecureRandom.base64(24)
-          end
+          self.reconnect_max_retries = opts.reconnect_max if opts.reconnect_max
+          @connection_pool_class = opts.connection_pool_class if opts.connection_pool_class.kind_of?(Class)
+          @redis_options = redis_options
+          @reconnect_max_retries ||= DEFAULT_RECONNECT_MAX_RETRIES
+          @redis_factory = opts.redis_factory if opts.redis_factory
+          @redis_factory ||= proc {|opts| Redis.new opts }
+          raise TypeError, "redis_factory should respond to [] method" unless @redis_factory.respond_to?(:[])
+          @@ns = opts.ns if opts.ns
           unless (@@redis_pool = redis)
-            unless @@connection_pool_class
+            unless @connection_pool_class
               begin
                 require 'em-synchrony/connection_pool' unless defined?(::EM::Synchrony::ConnectionPool)
               rescue LoadError
                 raise ":connection_pool_class required; could not fall back to EM::Synchrony::ConnectionPool - gem install em-synchrony"
               end
-              @@connection_pool_class = ::EM::Synchrony::ConnectionPool
+              @connection_pool_class = ::EM::Synchrony::ConnectionPool
             end
-            @@redis_pool = @@connection_pool_class.new(size: pool_size) do
-              Redis.new redis_options
+            @@redis_pool = @connection_pool_class.new(size: pool_size) do
+              @redis_factory[redis_options]
             end
           end
-          @@redis_watcher = Redis.new redis_options
+          @redis_watcher = @redis_factory[redis_options]
           start_watcher if ::EM.reactor_running?
         end
 
+        def ready?
+          !!@@redis_pool
+        end
+
         # resets Mutex's automatic name generator
         def reset_autoname
           @@name_index = AUTO_NAME_SEED
@@ -497,20 +510,20 @@ class Redis
         # If EventMachine is to be re-started (or after EM.fork_reactor) this method may be used instead of
         # Mutex.setup for "lightweight" startup procedure.
         def start_watcher
-          raise MutexError, "call #{self.class}::setup first" unless @@redis_watcher
+          raise MutexError, "call #{self.class}::setup first" unless @redis_watcher
           return if watching?
           if @@watching # Process id changed, we've been forked alive!
-            @@redis_watcher = Redis.new @redis_options
+            @redis_watcher = @redis_factory[@redis_options]
             @@signal_queue.clear
           end
           @@watching = $$
           retries = 0
           Fiber.new do
             begin
-              @@redis_watcher.subscribe(SIGNAL_QUEUE_CHANNEL) do |on|
+              @redis_watcher.subscribe(SIGNAL_QUEUE_CHANNEL) do |on|
                 on.subscribe do |channel,|
                   if channel == SIGNAL_QUEUE_CHANNEL
-                    @@watcher_subscribed = true
+                    @watcher_subscribed = true
                     retries = 0
                     wakeup_queue_all
                   end
@@ -527,22 +540,22 @@ class Redis
                   end
                 end
                 on.unsubscribe do |channel,|
-                  @@watcher_subscribed = false if channel == SIGNAL_QUEUE_CHANNEL
+                  @watcher_subscribed = false if channel == SIGNAL_QUEUE_CHANNEL
                 end
               end
               break
             rescue Redis::BaseConnectionError, EventMachine::ConnectionError => e
-              @@watcher_subscribed = false
+              @watcher_subscribed = false
               warn e.message
               retries+= 1
-              if retries > @@connection_retry_max && @@connection_retry_max >= 0
+              if retries > reconnect_max_retries && reconnect_max_retries >= 0
                 @@watching = false
               else
                 sleep retries > 1 ? 1 : 0.1
               end
             end while watching?
           end.resume
-          until @@watcher_subscribed
+          until @watcher_subscribed
             raise MutexError, "Can not establish watcher channel connection!" unless watching?
             fiber = Fiber.current
             ::EM.next_tick { fiber.resume }
@@ -558,22 +571,22 @@ class Redis
         end
 
         # Stops the watcher of the "unlock" channel.
-        # It should be called before stoping EvenMachine otherwise
+        # It should be called before stopping EvenMachine otherwise
         # EM might wait forever for channel connection to be closed.
         #
-        # Raises MutexError if there are still some fibers waiting for a lock.
+        # Raises MutexError if there are still some fibers waiting for lock.
         # Pass `true` to forcefully stop it. This might instead cause
         # MutexError to be raised in waiting fibers.
         def stop_watcher(force = false)
           return unless watching?
-          raise MutexError, "call #{self.class}::setup first" unless @@redis_watcher
+          raise MutexError, "call #{self.class}::setup first" unless @redis_watcher
           unless @@signal_queue.empty? || force
             raise MutexError, "can't stop: active signal queue handlers"
           end
           @@watching = false
-          if @@watcher_subscribed
-            @@redis_watcher.unsubscribe SIGNAL_QUEUE_CHANNEL
-            while @@watcher_subscribed
+          if @watcher_subscribed
+            @redis_watcher.unsubscribe SIGNAL_QUEUE_CHANNEL
+            while @watcher_subscribed
               fiber = Fiber.current
               ::EM.next_tick { fiber.resume }
               Fiber.yield

data/redis-em-mutex.gemspec

@@ -15,9 +15,9 @@ Gem::Specification.new do |s|
   s.files = `git ls-files`.split("\n") - ['.gitignore']
   s.test_files = Dir.glob("spec/**/*")
   s.rdoc_options << "--title" << "redis-em-mutex" <<
-    "--main" << "README.rdoc"
+    "--main" << "README.md"
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.rdoc"]
+  s.extra_rdoc_files = ["README.md"]
   s.requirements << "Redis server 2.4+"
   s.add_runtime_dependency "redis", ">= 3.0.1"
   s.add_runtime_dependency "hiredis", "~> 0.4.5"

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

@@ -106,14 +106,19 @@ describe Redis::EM::Mutex do
     mutex = described_class.new(*@lock_names)
     resource = ::EM::Synchrony::Thread::ConditionVariable.new
     signal = nil
+    delta = nil
     fiber = Fiber.current
     ::EM::Synchrony.next_tick do
       mutex.synchronize {
+        signal = true
         resource.wait(mutex)
         fiber.resume Time.now
       }
     end
     ::EM::Synchrony.next_tick do
+      t1 = Time.now
+      ::EM::Synchrony.sleep(0.01) while signal.nil?
+      delta = Time.now - t1
       mutex.synchronize {
         ::EM::Synchrony.sleep(0.2)
         resource.signal
@@ -123,7 +128,7 @@ describe Redis::EM::Mutex do
     start = Time.now
     now = Fiber.yield
     (now - signal).should be_within(0.002).of(0.001)
-    (now - start).should be_within(0.01).of(0.2)
+    (now - start).should be_within(0.01).of(0.2 + delta)
     mutex.synchronize do
       signal = nil
     end

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

@@ -3,6 +3,8 @@ require 'em-synchrony'
 require 'em-synchrony/connection_pool'
 require 'redis-em-mutex'
 
+class TestDummyConnectionPool < EM::Synchrony::ConnectionPool; end
+
 describe Redis::EM::Mutex do
 
   it "should raise MutexError while redis server not found on setup" do
@@ -22,7 +24,7 @@ describe Redis::EM::Mutex do
   it "should setup with redis connection pool" do
     described_class.setup(redis: @redis_pool)
     described_class.class_variable_get(:'@@redis_pool').should be @redis_pool
-    redis = described_class.class_variable_get(:'@@redis_watcher')
+    redis = described_class.instance_variable_get(:'@redis_watcher')
     described_class.stop_watcher
     redis.should be_an_instance_of Redis
     redis.client.host.should eq 'localhost'
@@ -32,15 +34,18 @@ describe Redis::EM::Mutex do
 
   it "should setup with various options" do
     described_class.setup do |cfg|
-      cfg.expire = 42 #   - sets global Mutex.default_expire 
-      cfg.ns = 'redis rulez!' #       - sets global Mutex.namespace
-      cfg.reconnect_max = -1 # - maximum num. of attempts to re-establish
+      cfg.expire = 42                # - sets global Mutex.default_expire
+      cfg.ns = 'redis rulez!'        # - sets global Mutex.namespace
+      cfg.reconnect_max = :forever   # - maximum num. of attempts to re-establish
       cfg.url = 'redis://127.0.0.1/2'
       cfg.size = 10
     end
     described_class.namespace.should eq 'redis rulez!'
     described_class.default_expire.should eq 42
-    described_class.class_variable_get(:'@@connection_retry_max').should eq -1
+    described_class.reconnect_forever?.should be true
+    described_class.instance_variable_get(:'@reconnect_max_retries').should eq -1
+    described_class.reconnect_max_retries = 0
+    described_class.reconnect_forever?.should be false
     redis_pool = described_class.class_variable_get(:'@@redis_pool')
     redis_pool.should be_an_instance_of EM::Synchrony::ConnectionPool
     redis_pool.should_not be @redis_pool
@@ -48,7 +53,7 @@ describe Redis::EM::Mutex do
     redis_pool.client.db.should eq 2
     redis_pool.client.port.should eq 6379
     redis_pool.client.scheme.should eq 'redis'
-    redis = described_class.class_variable_get(:'@@redis_watcher')
+    redis = described_class.instance_variable_get(:'@redis_watcher')
     described_class.stop_watcher
     redis.should be_an_instance_of Redis
     redis.client.host.should eq '127.0.0.1'
@@ -63,15 +68,16 @@ describe Redis::EM::Mutex do
       cfg.host = 'localhost'
       cfg.port = 6379
       cfg.db = 3
+      cfg.connection_pool_class = TestDummyConnectionPool
     end
     redis_pool = described_class.class_variable_get(:'@@redis_pool')
-    redis_pool.should be_an_instance_of EM::Synchrony::ConnectionPool
+    redis_pool.should be_an_instance_of TestDummyConnectionPool
     redis_pool.should_not be @redis_pool
     redis_pool.client.host.should eq 'localhost'
     redis_pool.client.db.should eq 3
     redis_pool.client.port.should eq 6379
     redis_pool.client.scheme.should eq 'redis'
-    redis = described_class.class_variable_get(:'@@redis_watcher')
+    redis = described_class.instance_variable_get(:'@redis_watcher')
     redis.should be_an_instance_of Redis
     described_class.stop_watcher
     redis.client.host.should eq 'localhost'
@@ -80,17 +86,50 @@ describe Redis::EM::Mutex do
     redis.client.scheme.should eq 'redis'  
   end
 
+  it "should be able to setup with redis factory" do
+    counter = 0
+    described_class.setup do |cfg|
+      cfg.redis = @redis_pool
+      cfg.redis_factory = proc do |opts|
+        counter += 1
+        Redis.new opts
+      end
+    end
+    counter.should eq 1
+    counter = 0
+    described_class.setup do |cfg|
+      cfg.size = 5
+      cfg.redis_factory = proc do |opts|
+        counter += 1
+        Redis.new opts
+      end
+    end
+    counter.should eq 6
+  end
+
+
   it "should be able to sleep" do
     t = Time.now
     described_class.sleep 0.11
     (Time.now - t).should be_within(0.02).of(0.11)
   end
 
+  it "should not change uuid" do
+    @uuid.should be_an_instance_of String
+    described_class.class_variable_get(:@@uuid).should eq @uuid
+  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
@@ -100,5 +139,6 @@ describe Redis::EM::Mutex do
 
   before(:all) do
     @redis_pool = EM::Synchrony::ConnectionPool.new(size: 10) { Redis.new url: 'redis://localhost/1' }
+    @uuid = described_class.class_variable_get(:@@uuid)
   end
 end

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

@@ -6,6 +6,10 @@ require 'redis-em-mutex'
 
 describe Redis::EM::Mutex do
 
+  it "should be ready" do
+    described_class.ready?.should be true
+  end
+
   it "should lock and prevent locking on the same semaphore" do
     described_class.new(@lock_names.first).owned?.should be false
     mutex = described_class.lock(@lock_names.first)
@@ -83,6 +87,7 @@ describe Redis::EM::Mutex do
     mutex.should be_an_instance_of described_class
     mutex.owned?.should be true
     locked = true
+    start = nil
     ::EM::Synchrony.next_tick do
       begin
         locked.should be true
@@ -96,7 +101,6 @@ describe Redis::EM::Mutex do
         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|
           begin
             locked.should be true
@@ -122,6 +126,7 @@ describe Redis::EM::Mutex do
 
     locked = true
     mutex.lock.should be true
+    start = Time.now
     ::EM::Synchrony.sleep 0.25
     locked = 10
     mutex.unlock.should be_an_instance_of described_class
@@ -283,19 +288,24 @@ describe Redis::EM::Mutex do
   end
 
   it "should lock and the other process should acquire lock as soon as possible" do
+    described_class.watching?.should be false
     mutex = described_class.lock(*@lock_names)
+    described_class.watching?.should be true
     mutex.should be_an_instance_of described_class
     time_key1 = SecureRandom.random_bytes
     time_key2 = SecureRandom.random_bytes
     ::EM.fork_reactor do
+      described_class.watching?.should be false
       Fiber.new do
         begin
           redis = Redis.new @redis_options
           redis.set time_key1, Time.now.to_f.to_s
           mutex.synchronize do
+            described_class.watching?.should be true
             redis.set time_key2, Time.now.to_f.to_s
           end
           described_class.stop_watcher(false)
+          described_class.watching?.should be false
         # rescue => e
         #   warn e.inspect
         ensure
@@ -303,7 +313,9 @@ describe Redis::EM::Mutex do
         end
       end.resume
     end
+    described_class.watching?.should be true
     EM::Synchrony.sleep 0.25
+    described_class.watching?.should be true
     mutex.owned?.should be true
     mutex.unlock.should be_an_instance_of described_class
     time = Time.now.to_f
@@ -314,7 +326,6 @@ describe Redis::EM::Mutex do
     t1.should be_an_instance_of String
     t1.to_f.should be < time - 0.25
     t2.should be_an_instance_of String
-    t2.to_f.should be > time
     t2.to_f.should be_within(0.001).of(time)
     redis.del(time_key1, time_key2)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-em-mutex
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-26 00:00:00.000000000 Z
+date: 2013-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &219325340 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: 3.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *219325340
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &219340740 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: 0.4.5
   type: :runtime
   prerelease: false
-  version_requirements: *219340740
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &219339740 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: 1.0.0.beta.1
   type: :runtime
   prerelease: false
-  version_requirements: *219339740
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.1
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &219338960 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +69,15 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *219338960
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &219338220 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +85,15 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *219338220
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &219337400 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,17 +101,22 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *219337400
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: Cross server-process-fiber EventMachine + Redis based semaphore with
   many features
 email: rafal@yeondir.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
 - HISTORY.rdoc
-- README.rdoc
+- README.md
 - Rakefile
 - lib/redis-em-mutex.rb
 - lib/redis/em-mutex.rb
@@ -107,7 +137,7 @@ rdoc_options:
 - --title
 - redis-em-mutex
 - --main
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -125,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Redis server 2.4+
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Cross server-process-fiber EventMachine + Redis based semaphore