redis-em-mutex 0.2.3 → 0.3.0

data/lib/redis/em-mutex.rb

@@ -41,24 +41,34 @@ class Redis
       @@watching = false
       @@signal_queue = Hash.new {|h,k| h[k] = []}
       @@ns = nil
+      @@handler = nil
       @@uuid ||= if SecureRandom.respond_to?(:uuid)
         SecureRandom.uuid
       else
         SecureRandom.base64(24)
       end
 
-      attr_reader :names, :ns, :block_timeout
-      alias_method :namespace, :ns
+      private
 
-      def expire_timeout; @expire_timeout || @@default_expire; end
+      def signal_queue; @@signal_queue end
+      def uuid; @@uuid; end
+      def redis_pool; @@redis_pool end
 
-      def expire_timeout=(value)
-        raise ArgumentError, "#{self.class.name}\#expire_timeout value must be greater than 0" unless (value = value.to_f) > 0
-        @expire_timeout = value
+      public
+
+      # Selected implementation handler module name
+      def self.handler; @@handler && @@handler.name end
+
+      # Whether selected implementation handler
+      # supports refreshing of already expired locks.
+      def self.can_refresh_expired?
+        @@handler.can_refresh_expired?
       end
 
-      def block_timeout=(value)
-        @block_timeout = value.nil? ? nil : value.to_f
+      # Whether selected implementation handler
+      # supports refreshing of already expired locks.
+      def can_refresh_expired?
+        @@handler.can_refresh_expired?
       end
 
       # Creates a new cross machine/process/fiber semaphore
@@ -77,6 +87,7 @@ class Redis
       # Raises ArgumentError on invalid options.
       def initialize(*args)
         raise MutexError, "call #{self.class}::setup first" unless @@redis_pool
+        self.class.setup_handler unless @@handler
 
         opts = args.last.kind_of?(Hash) ? args.pop : {}
 
@@ -87,243 +98,35 @@ class Redis
         @multi = !@names.one?
         @ns = opts[:ns] || @@ns
         @ns_names = @ns ? @names.map {|n| "#@ns:#{n}".freeze }.freeze : @names.map {|n| n.to_s.dup.freeze }.freeze
+        @marsh_names = Marshal.dump(@ns_names)
         self.expire_timeout = opts[:expire] if opts.key?(:expire)
         self.block_timeout = opts[:block] if opts.key?(:block)
-        @locked_owner_id = @locked_id = nil
-        if (owner = opts[:owner])
-          self.define_singleton_method(:owner_ident) do |lock_id = nil|
-            if lock_id
-              "#@@uuid$#$$@#{owner} #{lock_id}"
-            else
-              "#@@uuid$#$$@#{owner}"
-            end
-          end
-        end
-      end
-
-      # Returns `true` if this semaphore (at least one of locked `names`) is currently being held by some owner.
-      def locked?
-        if @multi
-          @@redis_pool.multi do |multi|
-            @ns_names.each {|n| multi.exists n}
-          end.any?
-        else
-          @@redis_pool.exists @ns_names.first
-        end
-      end
-
-      # Returns `true` if this semaphore (all the locked `names`) is currently being held by calling owner.
-      # This is the method you should use to check if lock is still held and valid.
-      def owned?
-        !!if @locked_id && owner_ident(@locked_id) == (lock_full_ident = @locked_owner_id)
-          @@redis_pool.mget(*@ns_names).all? {|v| v == lock_full_ident}
-        end
-      end
-
-      # Returns `true` when the semaphore is being held and have already expired.
-      # Returns `false` when the semaphore is still locked and valid
-      # or `nil` if the semaphore wasn't locked by current owner.
-      #
-      # The check is performed only on the Mutex object instance and should only be used as a hint.
-      # For reliable lock status information use #refresh or #owned? instead.
-      def expired?
-        Time.now.to_f > @locked_id.to_f if @locked_id && owner_ident(@locked_id) == @locked_owner_id
-      end
-
-      # Returns the number of seconds left until the semaphore expires.
-      # The number of seconds less than 0 means that the semaphore expired and could be grabbed
-      # by some other owner.
-      # Returns `nil` if the semaphore wasn't locked by current owner.
-      #
-      # The check is performed only on the Mutex object instance and should only be used as a hint.
-      # For reliable lock status information use #refresh or #owned? instead.
-      def expires_in
-        @locked_id.to_f - Time.now.to_f if @locked_id && owner_ident(@locked_id) == @locked_owner_id
+        self.extend(@@handler)
+        post_init(opts)
       end
 
-      # Returns local time at which the semaphore will expire or have expired.
-      # Returns `nil` if the semaphore wasn't locked by current owner.
-      #
-      # The check is performed only on the Mutex object instance and should only be used as a hint.
-      # For reliable lock status information use #refresh or #owned? instead.
-      def expires_at
-        Time.at(@locked_id.to_f) if @locked_id && owner_ident(@locked_id) == @locked_owner_id
-      end
-
-      # Returns timestamp at which the semaphore will expire or have expired.
-      # Returns `nil` if the semaphore wasn't locked by current owner.
-      #
-      # The check is performed only on the Mutex object instance and should only be used as a hint.
-      # For reliable lock status information use #refresh or #owned? instead.
-      def expiration_timestamp
-        @locked_id.to_f if @locked_id && owner_ident(@locked_id) == @locked_owner_id
-      end
+      attr_reader :names, :ns, :block_timeout
+      alias_method :namespace, :ns
 
-      # Attempts to obtain the lock and returns immediately.
-      # Returns `true` if the lock was granted.
-      # Use Mutex#expire_timeout= to set lock expiration time in secods.
-      # Otherwise global Mutex.default_expire is used.
-      #
-      # This method doesn't capture expired semaphores
-      # and therefore it should not be used under normal circumstances.
-      # Use Mutex#lock with block_timeout = 0 to obtain expired lock without blocking.
-      def try_lock
-        lock_id = (Time.now + expire_timeout).to_f.to_s
-        lock_full_ident = owner_ident(lock_id)
-        !!if @multi
-          if @@redis_pool.msetnx(*@ns_names.map {|k| [k, lock_full_ident]}.flatten)
-            @locked_id = lock_id
-            @locked_owner_id = lock_full_ident
-          end
-        elsif @@redis_pool.setnx(@ns_names.first, lock_full_ident)
-          @locked_id = lock_id
-          @locked_owner_id = lock_full_ident
-        end
-      end
+      def expire_timeout; @expire_timeout || @@default_expire; end
 
-      # Refreshes lock expiration timeout.
-      # Returns `true` if refresh was successfull.
-      # Returns `false` if the semaphore wasn't locked or when it was locked but it has expired
-      # and now it's got a new owner.
-      def refresh(expire_timeout=nil)
-        ret = false
-        if @locked_id && owner_ident(@locked_id) == (lock_full_ident = @locked_owner_id)
-          new_lock_id = (Time.now + (expire_timeout.to_f.nonzero? || self.expire_timeout)).to_f.to_s
-          new_lock_full_ident = owner_ident(new_lock_id)
-          @@redis_pool.execute(false) do |r|
-            r.watch(*@ns_names) do
-              if r.mget(*@ns_names).all? {|v| v == lock_full_ident}
-                if r.multi {|m| m.mset(*@ns_names.map {|k| [k, new_lock_full_ident]}.flatten)}
-                  @locked_id = new_lock_id
-                  @locked_owner_id = new_lock_full_ident
-                  ret = true
-                end
-              else
-                r.unwatch
-              end
-            end
-          end
-        end
-        ret
+      def expire_timeout=(value)
+        raise ArgumentError, "#{self.class.name}\#expire_timeout value must be greater than 0" unless (value = value.to_f) > 0
+        @expire_timeout = value
       end
 
-      # Releases the lock. Returns self on success.
-      # Returns `false` if the semaphore wasn't locked or when it was locked but it has expired
-      # and now it's got a new owner.
-      # In case of unlocking multiple name semaphore this method returns self only when all
-      # of the names have been unlocked successfully.
-      def unlock!
-        sem_left = @ns_names.length
-        if @locked_id && owner_ident(@locked_id) == (lock_full_ident = @locked_owner_id)
-          @locked_owner_id = @locked_id = nil
-          @@redis_pool.execute(false) do |r|
-            @ns_names.each do |name|
-              r.watch(name) do
-                if r.get(name) == lock_full_ident
-                  if (r.multi {|multi|
-                      multi.del(name)
-                      multi.publish SIGNAL_QUEUE_CHANNEL, Marshal.dump([name])
-                    })
-                    sem_left -= 1
-                  end
-                else
-                  r.unwatch
-                end
-              end
-            end
-          end
-        end
-        sem_left.zero? && self
+      def block_timeout=(value)
+        @block_timeout = value.nil? ? nil : value.to_f
       end
 
       # Releases the lock unconditionally.
-      # If the semaphore wasn’t locked by the current owner it is silently ignored.
+      # If the semaphore wasn't locked by the current owner it is silently ignored.
       # Returns self.
       def unlock
         unlock!
         self
       end
 
-      # Attempts to grab the lock and waits if it isn’t available.
-      # Raises MutexError if mutex was locked by the current owner.
-      # Returns `true` if lock was successfully obtained.
-      # Returns `false` if lock wasn't available within `block_timeout` seconds.
-      #
-      # If `block_timeout` is `nil` or omited this method uses Mutex#block_timeout.
-      # If also Mutex#block_timeout is nil this method returns only after lock
-      # has been granted.
-      #
-      # Use Mutex#expire_timeout= to set lock expiration timeout.
-      # Otherwise global Mutex.default_expire is used.
-      def lock(block_timeout = nil)
-        block_timeout||= self.block_timeout
-        names = @ns_names
-        timer = fiber = nil
-        try_again = false
-        handler = proc do
-          try_again = true
-          ::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
-            start_time = Time.now.to_f
-            expire_time = nil
-            @@redis_pool.execute(false) do |r|
-              r.watch(*names) do
-                expired_names = names.zip(r.mget(*names)).map do |name, lock_value|
-                  if lock_value
-                    owner, exp_id = lock_value.split ' '
-                    exp_time = exp_id.to_f
-                    expire_time = exp_time if expire_time.nil? || exp_time < expire_time
-                    raise MutexError, "deadlock; recursive locking #{owner}" if owner == ident_match
-                    if exp_time < start_time
-                      name
-                    end
-                  end
-                end
-                if expire_time && expire_time < start_time
-                  r.multi do |multi|
-                    expired_names = expired_names.compact
-                    multi.del(*expired_names)
-                    multi.publish SIGNAL_QUEUE_CHANNEL, Marshal.dump(expired_names)
-                  end
-                else
-                  r.unwatch
-                end
-              end
-            end
-            timeout = (expire_time = expire_time.to_f) - start_time
-            timeout = block_timeout if block_timeout && block_timeout < timeout
-
-            if !try_again && timeout > 0
-              timer = ::EM::Timer.new(timeout) do
-                timer = nil
-                ::EM.next_tick { fiber.resume if fiber } if fiber
-              end
-              fiber = Fiber.current
-              Fiber.yield
-              fiber = nil
-            end
-            finish_time = Time.now.to_f
-            if try_again || finish_time > expire_time
-              block_timeout-= finish_time - start_time if block_timeout
-              try_again = false
-            else
-              return false
-            end
-          end
-          true
-        ensure
-          timer.cancel if timer
-          timer = nil
-          queues.each {|q| q.delete handler }
-          names.each {|n| @@signal_queue.delete(n) if @@signal_queue[n].empty? }
-        end
-      end
-
       # Wakes up currently sleeping fiber on a mutex.
       def wakeup(fiber)
         fiber.resume if @slept.delete(fiber)
@@ -333,7 +136,7 @@ class Redis
       alias_method :_wakeup, :wakeup
 
       # Releases the lock and sleeps `timeout` seconds if it is given and non-nil or forever.
-      # Raises MutexError if mutex wasn’t locked by the current owner.
+      # Raises MutexError if mutex wasn't locked by the current owner.
       # Raises MutexTimeout if #block_timeout= was set and timeout
       # occured while locking after sleep.
       # If code block is provided it is executed after waking up, just before grabbing a lock.
@@ -405,15 +208,19 @@ class Redis
           @@default_expire = value
         end
 
-        # Setup redis database and other defaults
+        # Setup redis database and other defaults.
         # MUST BE called once before any semaphore is created.
         #
         # opts = options Hash:
         #
         # global options:
         #
-        # - :connection_pool_class - default is ::EM::Synchrony::ConnectionPool
-        # - :redis_factory - default is proc {|opts| Redis.new opts }
+        # - :connection_pool_class - default is Redis::EM::ConnectionPool
+        # - :redis_factory - default is proc {|redis_opts| Redis.new redis_opts }
+        # - :handler - the default value is taken from envronment variable: REDIS_EM_MUTEX_HANDLER or :auto
+        #     :pure   - optimistic locking commands based (redis-server >= 2.4)
+        #     :script - server scripting based (redis-server >= 2.6)
+        #     :auto   - autodetect and choose best available handler
         # - :expire   - sets global Mutex.default_expire 
         # - :ns       - sets global Mutex.namespace
         # - :reconnect_max - maximum num. of attempts to re-establish
@@ -476,11 +283,11 @@ class Redis
           unless (@@redis_pool = redis)
             unless @connection_pool_class
               begin
-                require 'em-synchrony/connection_pool' unless defined?(::EM::Synchrony::ConnectionPool)
+                require 'redis/em-connection-pool' unless defined?(Redis::EM::ConnectionPool)
               rescue LoadError
-                raise ":connection_pool_class required; could not fall back to EM::Synchrony::ConnectionPool - gem install em-synchrony"
+                raise ":connection_pool_class required; could not fall back to Redis::EM::ConnectionPool"
               end
-              @connection_pool_class = ::EM::Synchrony::ConnectionPool
+              @connection_pool_class = Redis::EM::ConnectionPool
             end
             @@redis_pool = @connection_pool_class.new(size: pool_size) do
               @redis_factory[redis_options]
@@ -488,6 +295,37 @@ class Redis
           end
           @redis_watcher = @redis_factory[redis_options]
           start_watcher if ::EM.reactor_running?
+
+          case handler = opts.handler || @@handler
+          when Module
+            @@handler = handler
+          when nil, Symbol, String
+            setup_handler(handler)
+          else
+            raise TypeError, 'handler must be Symbol or Module'
+          end
+        end
+
+        def setup_handler(handler = nil)
+          handler = (handler || ENV['REDIS_EM_MUTEX_HANDLER'] || :auto).to_sym.downcase
+          if handler == :auto
+            return unless ::EM.reactor_running?
+            handler = :script
+            begin
+              @@redis_pool.script(:exists)
+            rescue Redis::CommandError
+              handler = :pure
+            end
+          end
+          const_name = "#{handler.to_s.capitalize}HandlerMixin"
+          begin
+            unless self.const_defined?(const_name)
+              require "redis/em-mutex/#{handler}_handler"
+            end
+            @@handler = self.const_get(const_name)
+          rescue LoadError, NameError
+            raise "handler: #{handler} not found"
+          end
         end
 
         def ready?
@@ -530,12 +368,12 @@ class Redis
                 end
                 on.message do |channel, message|
                   if channel == SIGNAL_QUEUE_CHANNEL
-                    handlers = {}
+                    sig_match = {}
                     Marshal.load(message).each do |name|
-                      handlers[@@signal_queue[name].first] = true if @@signal_queue.key?(name)
+                      sig_match[@@signal_queue[name].first] = true if @@signal_queue.key?(name)
                     end
-                    handlers.keys.each do |handler|
-                      handler.call if handler
+                    sig_match.keys.each do |sig_proc|
+                      sig_proc.call if sig_proc
                     end
                   end
                 end
@@ -581,7 +419,7 @@ class Redis
           return unless watching?
           raise MutexError, "call #{self.class}::setup first" unless @redis_watcher
           unless @@signal_queue.empty? || force
-            raise MutexError, "can't stop: active signal queue handlers"
+            raise MutexError, "can't stop: semaphores in queue"
           end
           @@watching = false
           if @watcher_subscribed
@@ -601,7 +439,7 @@ class Redis
           raise NotImplementedError
         end
 
-        # Attempts to grab the lock and waits if it isn’t available.
+        # Attempts to grab the lock and waits if it isn't available.
         # Raises MutexError if mutex was locked by the current owner
         # or if used before Mutex.setup.
         # Raises ArgumentError on invalid options.
@@ -640,14 +478,7 @@ class Redis
         def synchronize(*args, &block)
           new(*args).synchronize(&block)
         end
-      end
 
-      def owner_ident(lock_id = nil)
-        if lock_id
-          "#@@uuid$#$$@#{Fiber.current.__id__} #{lock_id}"
-        else
-          "#@@uuid$#$$@#{Fiber.current.__id__}"
-        end
       end
 
     end

data/redis-em-mutex.gemspec

@@ -17,9 +17,9 @@ Gem::Specification.new do |s|
   s.rdoc_options << "--title" << "redis-em-mutex" <<
     "--main" << "README.md"
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.md"]
+  s.extra_rdoc_files = ["README.md", "BENCHMARK.md"]
   s.requirements << "Redis server 2.4+"
-  s.add_runtime_dependency "redis", ">= 3.0.1"
+  s.add_runtime_dependency "redis", ">= 3.0.2"
   s.add_runtime_dependency "hiredis", "~> 0.4.5"
   s.add_runtime_dependency "eventmachine", ">= 1.0.0.beta.1"
   s.add_development_dependency "rspec", "~> 2.8.0"

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

@@ -15,8 +15,8 @@ describe Redis::EM::Mutex do
       ::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.sleep.should be_within(0.015).of(0.25)
+      (Time.now - start).should be_within(0.015).of(0.25)
       mutex.owned?.should be true
       mutex.unlock!.should be_true
     ensure
@@ -71,7 +71,7 @@ describe Redis::EM::Mutex do
       ::EM::Synchrony.next_tick do
         begin
           mutex.owned?.should be false
-          mutex.lock.should be true
+          mutex.lock(0.001).should be true
           mutex.owned?.should be true
           mutex.wakeup(fiber)
           ::EM::Synchrony.sleep(0.2)

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

@@ -1,9 +1,9 @@
 $:.unshift "lib"
 require 'em-synchrony'
-require 'em-synchrony/connection_pool'
+require 'redis/em-connection-pool'
 require 'redis-em-mutex'
 
-class TestDummyConnectionPool < EM::Synchrony::ConnectionPool; end
+class TestDummyConnectionPool < Redis::EM::ConnectionPool; end
 
 describe Redis::EM::Mutex do
 
@@ -47,7 +47,7 @@ describe Redis::EM::Mutex do
     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 be_an_instance_of Redis::EM::ConnectionPool
     redis_pool.should_not be @redis_pool
     redis_pool.client.host.should eq '127.0.0.1'
     redis_pool.client.db.should eq 2
@@ -107,7 +107,6 @@ describe Redis::EM::Mutex do
     counter.should eq 6
   end
 
-
   it "should be able to sleep" do
     t = Time.now
     described_class.sleep 0.11
@@ -119,6 +118,69 @@ describe Redis::EM::Mutex do
     described_class.class_variable_get(:@@uuid).should eq @uuid
   end
 
+  it "owner_ident should begin with uuid and end with owner id" do
+    ident = described_class.new(:dummy).owner_ident
+    ident.should start_with(@uuid)
+    ident.should end_with(Fiber.current.__id__.to_s)
+    ident = described_class.new(:dummy, owner:'__me__').owner_ident
+    ident.should start_with(@uuid)
+    ident.should end_with('__me__')
+  end
+
+  context "Mutex implementation handlers:" do
+    it "should select desired handler" do
+      described_class.setup
+      expected_name = case ENV['REDIS_EM_MUTEX_HANDLER']
+      when /pure/i
+        described_class.handler.should eq 'Redis::EM::Mutex::PureHandlerMixin'
+      when /script/i
+        described_class.handler.should eq 'Redis::EM::Mutex::ScriptHandlerMixin'
+      end
+      described_class.setup(handler: :pUrE)
+      described_class.handler.should eq Redis::EM::Mutex::PureHandlerMixin.name
+      described_class.setup
+      described_class.handler.should eq Redis::EM::Mutex::PureHandlerMixin.name
+      described_class.setup {|opts| opts.handler = 'ScRiPt'}
+      described_class.handler.should eq Redis::EM::Mutex::ScriptHandlerMixin.name
+      described_class.setup
+      described_class.handler.should eq Redis::EM::Mutex::ScriptHandlerMixin.name
+      described_class.setup {|opts| opts.handler = Redis::EM::Mutex::PureHandlerMixin}
+      described_class.handler.should eq Redis::EM::Mutex::PureHandlerMixin.name
+      described_class.setup(handler: Redis::EM::Mutex::ScriptHandlerMixin)
+      described_class.handler.should eq Redis::EM::Mutex::ScriptHandlerMixin.name
+      described_class.setup {|opts| opts.handler = :auto}
+      other_handler, other_name = case described_class.handler
+      when Redis::EM::Mutex::ScriptHandlerMixin.name
+        [:pure, Redis::EM::Mutex::PureHandlerMixin.name]
+      when Redis::EM::Mutex::PureHandlerMixin.name
+        [:script, Redis::EM::Mutex::ScriptHandlerMixin.name]
+      end
+      other_handler.should_not be_nil
+      other_name.should_not be_nil
+      described_class.setup(handler: other_handler)
+      described_class.handler.should eq other_name
+      described_class.setup(handler: :auto)
+      described_class.handler.should_not eq other_name
+    end
+
+    it "should select pure handler with SCRIPT unsupporting redis-server" do
+      pool = Redis::EM::ConnectionPool.new(size: 1) { Redis.new }
+      pool.should_receive(:script).with(:exists).
+        and_raise(Redis::CommandError)
+      described_class.setup(redis: pool, handler: :auto)
+      described_class.handler.should eq Redis::EM::Mutex::PureHandlerMixin.name
+    end
+
+    it "should select script handler with SCRIPT aware redis-server" do
+      pool = Redis::EM::ConnectionPool.new(size: 1) { Redis.new }
+      pool.should_receive(:script).with(:exists).
+        and_return(false)
+      described_class.setup(redis: pool, handler: :auto)
+      described_class.handler.should eq Redis::EM::Mutex::ScriptHandlerMixin.name
+    end
+
+  end
+
   around(:each) do |testcase|
     @after_em_stop = nil
     @exception = nil
@@ -138,7 +200,7 @@ describe Redis::EM::Mutex do
   end
 
   before(:all) do
-    @redis_pool = EM::Synchrony::ConnectionPool.new(size: 10) { Redis.new url: 'redis://localhost/1' }
+    @redis_pool = Redis::EM::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

@@ -65,7 +65,7 @@ describe Redis::EM::Mutex do
         mutex.owned?.should be false
         start = Time.now
         mutex.synchronize do
-          (Time.now - start).should be_within(0.015).of(0.26)
+          (Time.now - start).should be_within(0.02).of(0.26)
           locked.should be false
           locked = nil
         end
@@ -96,7 +96,7 @@ describe Redis::EM::Mutex do
         start = Time.now
         mutex.synchronize do
           mutex.owned?.should be true
-          (Time.now - start).should be_within(0.015).of(0.26)
+          (Time.now - start).should be_within(0.02).of(0.26)
           locked.should be false
         end
         mutex.owned?.should be false
@@ -105,7 +105,7 @@ describe Redis::EM::Mutex do
           begin
             locked.should be true
             described_class.new(name).synchronize do
-              (Time.now - start).should be_within(0.015).of(0.26)
+              (Time.now - start).should be_within(0.02).of(0.26)
               locked.should be_an_instance_of Fixnum
               locked-= 1
             end
@@ -372,7 +372,12 @@ describe Redis::EM::Mutex do
       mutex.expires_at.should eq Time.at(mutex.expiration_timestamp)
       mutex.expires_at.should be < Time.now
       start = Time.now
-      mutex.refresh.should be true
+      if mutex.can_refresh_expired?
+        mutex.refresh.should be true
+      else
+        mutex.refresh.should be false
+        mutex.lock.should be true
+      end
       now = Time.now
       mutex.expires_in.should be_within(0.01).of(mutex.expire_timeout - (now - start))
       EM::Synchrony.sleep mutex.expires_in + 0.001

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-em-mutex
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-23 00:00:00.000000000 Z
+date: 2013-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.0.2
 - !ruby/object:Gem::Dependency
   name: hiredis
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +114,20 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
+- BENCHMARK.md
 files:
-- HISTORY.rdoc
+- BENCHMARK.md
+- HISTORY.md
 - README.md
 - Rakefile
+- benchmark_mutex.rb
 - lib/redis-em-mutex.rb
+- lib/redis/em-connection-pool.rb
 - lib/redis/em-mutex.rb
 - lib/redis/em-mutex/macro.rb
 - lib/redis/em-mutex/ns.rb
+- lib/redis/em-mutex/pure_handler.rb
+- lib/redis/em-mutex/script_handler.rb
 - lib/redis/em-mutex/version.rb
 - redis-em-mutex.gemspec
 - spec/redis-em-mutex-condition.rb