redis-mutex 2.1.0 → 4.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 938cf6fdd7b6baa536703e89f2f45dbdd7a7725ee2a8595e840515c8317dfac9
+  data.tar.gz: 172a141c6d8218384de2a45b861ff7ed2a85fbe4a8cd52d60a6b2c7a3bca6c76
+SHA512:
+  metadata.gz: 198b9c51d0f26c282d88f8d3d3555f283e3d5b57080c0a75788243359440a791c896ba32dca09b4f5c43f9a6d9a61eaff9621412ac9abb474a31b20aa17ff44e
+  data.tar.gz: 61009d9d9bb9c50697f48041f0535a366141234b9dab5480c500f9b00eb2f526ee92c1ee0d923adfe8192fb0dadf430714806627bcc948ee357fbc8130028c24

data/.travis.yml

@@ -1,12 +1,12 @@
 language: ruby
+services:
+  - redis-server
+before_install:
+  - gem install bundler
+  - gem update bundler
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - 2.7.0
   - ruby-head
-  - jruby-head
-  - ree

data/README.md

@@ -3,7 +3,7 @@ Redis Mutex
 
 [![Build Status](https://secure.travis-ci.org/kenn/redis-mutex.png)](http://travis-ci.org/kenn/redis-mutex)
 
-Distrubuted mutex in Ruby using Redis. Supports both **blocking** and **non-blocking** semantics.
+Distributed mutex in Ruby using Redis. Supports both **blocking** and **non-blocking** semantics.
 
 The idea was taken from [the official SETNX doc](http://redis.io/commands/setnx).
 
@@ -13,7 +13,7 @@ Synopsis
 In the following example, only one thread / process / server can enter the locked block at one time.
 
 ```ruby
-Redis::Mutex.with_lock(:your_lock_name) do
+RedisMutex.with_lock(:your_lock_name) do
   # do something exclusively
 end
 ```
@@ -21,7 +21,7 @@ end
 or
 
 ```ruby
-mutex = Redis::Mutex.new(:your_lock_name)
+mutex = RedisMutex.new(:your_lock_name)
 if mutex.lock
   # do something exclusively
   mutex.unlock
@@ -37,10 +37,24 @@ that you can configure any of these timing values, as explained later.
 
 Or if you want to immediately receive `false` on an unsuccessful locking attempt, you can change the mutex mode to **non-blocking**.
 
-Changes in v2.0
----------------
+Changelog
+---------
 
-* **Exception-based control flow**: Added `lock!` and `unlock!`, which raises an exception when fails to acquire a lock. Raises `Redis::Mutex::LockError` and `Redis::Mutex::UnlockError` respectively.
+### v4.0
+
+`redis-mutex` 4.0 has brought a few backward incompatible changes to follow the major upgrade of the underlying `redis-classy` gem.
+
+* The base class `Redis::Mutex` is now `RedisMutex`.
+* `Redis::Classy.db = Redis.new` is now `RedisClassy.redis = Redis.new`.
+
+### v3.0
+
+* Ruby 2.0 or later is required.
+* `auto_mutex` now takes `:on` for additional key scoping.
+
+### v2.0
+
+* **Exception-based control flow**: Added `lock!` and `unlock!`, which raises an exception when fails to acquire a lock. Raises `RedisMutex::LockError` and `RedisMutex::UnlockError` respectively.
 * **INCOMPATIBLE CHANGE**: `#lock` no longer accepts a block. Use `#with_lock` instead, which uses `lock!` internally and returns the value of block.
 * `unlock` returns boolean values for success / failure, for consistency with `lock`.
 
@@ -61,7 +75,7 @@ gem 'redis-mutex'
 Register the Redis server: (e.g. in `config/initializers/redis_mutex.rb` for Rails)
 
 ```ruby
-Redis::Classy.db = Redis.new(:host => 'localhost')
+RedisClassy.redis = Redis.new
 ```
 
 Note that Redis Mutex uses the `redis-classy` gem internally to organize keys in an isolated namespace.
@@ -69,7 +83,7 @@ Note that Redis Mutex uses the `redis-classy` gem internally to organize keys in
 There are a number of methods:
 
 ```ruby
-mutex = Redis::Mutex.new(key, options)    # Configure a mutex lock
+mutex = RedisMutex.new(key, options)    # Configure a mutex lock
 mutex.lock                                # Try to acquire the lock, returns false when failed
 mutex.lock!                               # Try to acquire the lock, raises exception when failed
 mutex.unlock                              # Try to release the lock, returns false when failed
@@ -78,20 +92,20 @@ mutex.locked?                             # Find out if resource already locked
 mutex.with_lock                           # Try to acquire the lock, execute the block, then return the value of the block.
                                           # Raises exception when failed to acquire the lock.
 
-Redis::Mutex.sweep                        # Remove all expired locks
-Redis::Mutex.with_lock(key, options)      # Shortcut to new + with_lock
+RedisMutex.sweep                        # Remove all expired locks
+RedisMutex.with_lock(key, options)      # Shortcut to new + with_lock
 ```
 
 The key argument can be symbol, string, or any Ruby objects that respond to `id` method, where the key is automatically set as
-`TheClass:id`. For any given key, `Redis::Mutex:` prefix will be automatically prepended. For instance, if you pass a `Room`
-object with id of `123`, the actual key in Redis will be `Redis::Mutex:Room:123`. The automatic prefixing and instance binding
-is the feature of `Redis::Classy` - for more internal details, refer to [Redis Classy](https://github.com/kenn/redis-classy).
+`TheClass:id`. For any given key, `RedisMutex:` prefix will be automatically prepended. For instance, if you pass a `Room`
+object with id of `123`, the actual key in Redis will be `RedisMutex:Room:123`. The automatic prefixing and instance binding
+is the feature of `RedisClassy` - for more internal details, refer to [Redis Classy](https://github.com/kenn/redis-classy).
 
 The initialize method takes several options.
 
 ```ruby
 :block  => 1    # Specify in seconds how long you want to wait for the lock to be released.
-                # Speficy 0 if you need non-blocking sematics and return false immediately. (default: 1)
+                # Specify 0 if you need non-blocking sematics and return false immediately. (default: 1)
 :sleep  => 0.1  # Specify in seconds how long the polling interval should be when :block is given.
                 # It is NOT recommended to go below 0.01. (default: 0.1)
 :expire => 10   # Specify in seconds when the lock should be considered stale when something went wrong
@@ -108,11 +122,11 @@ class RoomController < ApplicationController
   before_filter { @room = Room.find(params[:id]) }
   
   def enter
-    Redis::Mutex.with_lock(@room) do    # key => "Room:123"
+    RedisMutex.with_lock(@room) do    # key => "Room:123"
       # do something exclusively
     end
     render text: 'success!'
-  rescue Redis::Mutex::LockError
+  rescue RedisMutex::LockError
     render text: 'failed to acquire lock!'
   end
 end
@@ -123,7 +137,7 @@ put the `unlock` method in the `ensure` clause.
 
 ```ruby
 def enter
-  mutex = Redis::Mutex.new('non-blocking', block: 0, expire: 10.minutes)
+  mutex = RedisMutex.new('non-blocking', block: 0, expire: 10.minutes)
   if mutex.lock
     begin
       # do something exclusively
@@ -147,7 +161,7 @@ If you give a proc object to the `after_failure` option, it will get called afte
 
 ```ruby
 class JobController < ApplicationController
-  include Redis::Mutex::Macro
+  include RedisMutex::Macro
   auto_mutex :run, block: 0, after_failure: lambda { render text: 'failed to acquire lock!' }
 
   def run
@@ -156,3 +170,17 @@ class JobController < ApplicationController
   end
 end
 ```
+
+Also you can specify method arguments with the `on` option. The following creates a mutex key named `ItunesVerifier#perform:123456`, so that the same method can run in parallel as long as the `transaction_id` is different.
+
+```ruby
+class ItunesVerifier
+  include Sidekiq::Worker
+  include RedisMutex::Macro
+  auto_mutex :perform, on: [:transaction_id]
+
+  def perform(transaction_id)
+    ...
+  end
+end
+```

data/lib/redis-mutex.rb

@@ -1,5 +1,2 @@
 require 'redis-classy'
-
-class Redis
-  autoload :Mutex, 'redis/mutex'
-end
+require 'redis_mutex'

data/lib/redis_mutex.rb

@@ -0,0 +1,132 @@
+class RedisMutex < RedisClassy
+  #
+  # Options
+  #
+  # :block  => Specify in seconds how long you want to wait for the lock to be released. Speficy 0
+  #            if you need non-blocking sematics and return false immediately. (default: 1)
+  # :sleep  => Specify in seconds how long the polling interval should be when :block is given.
+  #            It is recommended that you do NOT go below 0.01. (default: 0.1)
+  # :expire => Specify in seconds when the lock should forcibly be removed when something went wrong
+  #            with the one who held the lock. (default: 10)
+  #
+  autoload :Macro, 'redis_mutex/macro'
+
+  DEFAULT_EXPIRE = 10
+  LockError = Class.new(StandardError)
+  UnlockError = Class.new(StandardError)
+  AssertionError = Class.new(StandardError)
+
+  def initialize(object, options={})
+    super(object.is_a?(String) || object.is_a?(Symbol) ? object : "#{object.class.name}:#{object.id}")
+    @block = options[:block] || 1
+    @sleep = options[:sleep] || 0.1
+    @expire = options[:expire] || DEFAULT_EXPIRE
+  end
+
+  def lock
+    self.class.raise_assertion_error if block_given?
+    @locking = false
+
+    if @block > 0
+      # Blocking mode
+      start_at = Time.now
+      while Time.now - start_at < @block
+        @locking = true and break if try_lock
+        sleep @sleep
+      end
+    else
+      # Non-blocking mode
+      @locking = try_lock
+    end
+    @locking
+  end
+
+  def try_lock
+    now = Time.now.to_f
+    @expires_at = now + @expire                       # Extend in each blocking loop
+
+    begin
+      return true if setnx(@expires_at)               # Success, the lock has been acquired
+    end until old_value = get                         # Repeat if unlocked before get
+
+    return false if old_value.to_f > now              # Check if the lock is still effective
+
+    # The lock has expired but wasn't released... BAD!
+    return true if getset(@expires_at).to_f <= now    # Success, we acquired the previously expired lock
+    return false # Dammit, it seems that someone else was even faster than us to remove the expired lock!
+  end
+
+  # Returns true if resource is locked. Note that nil.to_f returns 0.0
+  def locked?
+    get.to_f > Time.now.to_f
+  end
+
+  def unlock(force = false)
+    # Since it's possible that the operations in the critical section took a long time,
+    # we can't just simply release the lock. The unlock method checks if @expires_at
+    # remains the same, and do not release when the lock timestamp was overwritten.
+
+    if get == @expires_at.to_s or force
+      # Redis#del with a single key returns '1' or nil
+      !!del
+    else
+      false
+    end
+  end
+
+  def with_lock
+    if lock!
+      begin
+        @result = yield
+      ensure
+        unlock
+      end
+    end
+    @result
+  end
+
+  def lock!
+    lock or raise LockError, "failed to acquire lock #{key.inspect}"
+  end
+
+  def unlock!(force = false)
+    unlock(force) or raise UnlockError, "failed to release lock #{key.inspect}"
+  end
+
+  class << self
+    def sweep
+      return 0 if (all_keys = keys).empty?
+
+      now = Time.now.to_f
+      values = mget(*all_keys)
+
+      expired_keys = all_keys.zip(values).select do |key, time|
+        time && time.to_f <= now
+      end
+
+      expired_keys.each do |key, _|
+        # Make extra sure that anyone haven't extended the lock
+        del(key) if getset(key, now + DEFAULT_EXPIRE).to_f <= now
+      end
+
+      expired_keys.size
+    end
+
+    def lock(object, options = {})
+      raise_assertion_error if block_given?
+      new(object, options).lock
+    end
+
+    def lock!(object, options = {})
+      new(object, options).lock!
+    end
+
+    def with_lock(object, options = {}, &block)
+      new(object, options).with_lock(&block)
+    end
+
+    def raise_assertion_error
+      raise AssertionError, 'block syntax has been removed from #lock, use #with_lock instead'
+    end
+  end
+end

data/lib/redis_mutex/macro.rb

@@ -0,0 +1,61 @@
+class RedisMutex
+  module Macro
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class << self
+          attr_accessor :auto_mutex_methods
+        end
+        @auto_mutex_methods = {}
+      end
+    end
+
+    module ClassMethods
+      def auto_mutex(target, options={})
+        self.auto_mutex_methods[target] = options
+      end
+
+      def method_added(target)
+        return if target.to_s =~ /^auto_mutex_methods/
+        return unless self.auto_mutex_methods[target]
+        without_method  = "#{target}_without_auto_mutex"
+        with_method     = "#{target}_with_auto_mutex"
+        after_method    = "#{target}_after_failure"
+        return if method_defined?(without_method)
+        options = self.auto_mutex_methods[target]
+
+        if options[:after_failure].is_a?(Proc)
+          define_method(after_method, &options[:after_failure])
+        end
+        target_argument_names = instance_method(target.to_sym).parameters.map(&:last)
+        on_arguments = Array(options[:on])
+        mutex_arguments = on_arguments & target_argument_names
+        unknown_arguments = on_arguments - target_argument_names
+        if unknown_arguments.any?
+          raise ArgumentError, "You are trying to lock on unknown arguments: #{unknown_arguments.join(', ')}"
+        end
+
+        define_method(with_method) do |*args|
+          named_arguments =  Hash[target_argument_names.zip(args)]
+          arguments  = mutex_arguments.map { |name| named_arguments.fetch(name) }
+          key = format(
+            "%<class>s#%<target>s:%<arguments>s",
+            class: self.class.name,
+            target: target,
+            arguments: arguments.join(":")
+          )
+          begin
+            RedisMutex.with_lock(key, options) do
+              send(without_method, *args)
+            end
+          rescue RedisMutex::LockError
+            send(after_method, *args) if respond_to?(after_method)
+          end
+        end
+
+        alias_method without_method, target
+        alias_method target, with_method
+      end
+    end
+  end
+end

data/redis-mutex.gemspec

@@ -12,9 +12,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "redis-mutex"
   gem.require_paths = ["lib"]
-  gem.version       = '2.1.0' # retrieve this value by: Gem.loaded_specs['redis-mutex'].version.to_s
+  gem.version       = '4.0.2' # retrieve this value by: Gem.loaded_specs['redis-mutex'].version.to_s
 
-  gem.add_runtime_dependency "redis-classy", "~> 1.2"
+  gem.add_runtime_dependency "redis-classy", "~> 2.0"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "bundler"
 

data/spec/redis_mutex_macro_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+class C
+  include RedisMutex::Macro
+  auto_mutex :run_singularly, :block => 0, :after_failure => lambda {|id| return "failure: #{id}" }
+
+  def run_singularly(id)
+    sleep 0.1
+    return "success: #{id}"
+  end
+
+  auto_mutex :run_singularly_on_args, :block => 0, :on => [:id, :bar], :after_failure => lambda {|id, *others| return "failure: #{id}" }
+  def run_singularly_on_args(id, foo, bar)
+    sleep 0.1
+    return "success: #{id}"
+  end
+
+  auto_mutex :run_singularly_on_keyword_args, :block => 0, :on => [:id, :bar], :after_failure => lambda {|id: 1, **others| return "failure: #{id}" }
+  def run_singularly_on_keyword_args(id: 1, foo: 1, bar: 1)
+    sleep 0.1
+    return "success: #{id}"
+  end
+end
+
+describe RedisMutex::Macro do
+
+  def race(a, b)
+    t1 = Thread.new(&a)
+    # In most cases t1 wins, but make sure to give it a head start,
+    # not exceeding the sleep inside the method.
+    sleep 0.01
+    t2 = Thread.new(&b)
+    t1.join
+    t2.join
+  end
+
+  let(:object_arg) { Object.new }
+
+  it 'adds auto_mutex' do
+    race(
+      proc { expect(C.new.run_singularly(1)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly(2)).to eq("failure: 2") })
+  end
+
+  it 'adds auto_mutex on different args' do
+    race(
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_args(2, :'2', object_arg)).to eq("success: 2") })
+  end
+
+  it 'adds auto_mutex on same args' do
+    race(
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("failure: 1") })
+  end
+
+  it 'adds auto_mutex on different keyword args' do
+    race(
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 2, foo: :'2', bar: object_arg)).to eq("success: 2") })
+  end
+
+  it 'adds auto_mutex on same keyword args' do
+    race(
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("failure: 1") })
+  end
+
+  it 'raise exception if there is no such argument' do
+    expect {
+      class C
+        auto_mutex :run_without_such_args, :block => 0, :on => [:missing_arg]
+        def run_without_such_args(id)
+          return "success: #{id}"
+        end
+      end
+    }.to raise_error(ArgumentError) { |error|
+      expect(error.message).to eq 'You are trying to lock on unknown arguments: missing_arg'
+    }
+  end
+end

data/spec/redis_mutex_spec.rb

@@ -2,173 +2,192 @@ require 'spec_helper'
 
 SHORT_MUTEX_OPTIONS = { :block => 0.1, :sleep => 0.02 }
 
-class C
-  include Redis::Mutex::Macro
-  auto_mutex :run_singularly, :block => 0, :after_failure => lambda {|id| return "failure: #{id}" }
-
-  def run_singularly(id)
-    sleep 0.1
-    return "success: #{id}"
-  end
-end
-
-describe Redis::Mutex do
+describe RedisMutex do
   before do
-    Redis::Classy.flushdb
+    RedisClassy.flushdb
   end
 
   after :all do
-    Redis::Classy.flushdb
-    Redis::Classy.quit
+    RedisClassy.flushdb
+    RedisClassy.quit
   end
 
   it 'locks the universe' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex1.lock.should be_true
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex1.lock).to be_truthy
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.lock.should be_false
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.lock).to be_falsey
   end
 
   it 'fails to lock when the lock is taken' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.lock.should be_true    # mutex2 beats us to it
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.lock).to be_truthy    # mutex2 beats us to it
 
-    mutex1.lock.should be_false   # fail
+    expect(mutex1.lock).to be_falsey   # fail
   end
 
   it 'unlocks only once' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex.lock).to be_truthy
 
-    mutex.unlock.should be_true   # successfully released the lock
-    mutex.unlock.should be_false  # the lock no longer exists
+    expect(mutex.unlock).to be_truthy   # successfully released the lock
+    expect(mutex.unlock).to be_falsey  # the lock no longer exists
   end
 
   it 'prevents accidental unlock from outside' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex1.lock.should be_true
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex1.lock).to be_truthy
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.unlock.should be_false
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.unlock).to be_falsey
   end
 
   it 'sets expiration' do
     start = Time.now
     expires_in = 10
-    mutex = Redis::Mutex.new(:test_lock, :expire => expires_in)
+    mutex = RedisMutex.new(:test_lock, :expire => expires_in)
     mutex.with_lock do
-      mutex.get.to_f.should be_within(1.0).of((start + expires_in).to_f)
+      expect(mutex.get.to_f).to be_within(1.0).of((start + expires_in).to_f)
     end
-    mutex.get.should be_nil   # key should have been cleaned up
+    expect(mutex.get).to be_nil   # key should have been cleaned up
   end
 
   it 'overwrites a lock when existing lock is expired' do
     # stale lock from the far past
-    Redis::Mutex.set(:test_lock, Time.now - 60)
+    RedisMutex.on(:test_lock).set(Time.now - 60)
 
-    mutex = Redis::Mutex.new(:test_lock)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock)
+    expect(mutex.lock).to be_truthy
   end
 
   it 'fails to unlock the key if it took too long past expiration' do
-    mutex = Redis::Mutex.new(:test_lock, :expire => 0.1, :block => 0)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock, :expire => 0.1, :block => 0)
+    expect(mutex.lock).to be_truthy
     sleep 0.2   # lock expired
 
     # someone overwrites the expired lock
-    mutex2 = Redis::Mutex.new(:test_lock, :expire => 10, :block => 0)
-    mutex2.lock.should be_true
+    mutex2 = RedisMutex.new(:test_lock, :expire => 10, :block => 0)
+    expect(mutex2.lock).to be_truthy
 
     mutex.unlock
-    mutex.get.should_not be_nil   # lock should still be there
+    expect(mutex.get).not_to be_nil   # lock should still be there
   end
 
   it 'ensures unlocking when something goes wrong in the block' do
-    mutex = Redis::Mutex.new(:test_lock)
+    mutex = RedisMutex.new(:test_lock)
     begin
       mutex.with_lock do
         raise "Something went wrong!"
       end
     rescue RuntimeError
-      mutex.get.should be_nil
+      expect(mutex.get).to be_nil
     end
   end
 
   it 'resets locking state on reuse' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex.lock.should be_true
-    mutex.lock.should be_false
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex.lock).to be_truthy
+    expect(mutex.lock).to be_falsey
   end
 
   it 'tells about lock\'s state' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
     mutex.lock
 
-    mutex.should be_locked
+    expect(mutex).to be_locked
 
     mutex.unlock
-    mutex.should_not be_locked
+    expect(mutex).not_to be_locked
   end
 
   it 'tells that resource is not locked when lock is expired' do
-    mutex = Redis::Mutex.new(:test_lock, :expire => 0.1)
+    mutex = RedisMutex.new(:test_lock, :expire => 0.1)
     mutex.lock
 
     sleep 0.2 # lock expired now
 
-    mutex.should_not be_locked
+    expect(mutex).not_to be_locked
   end
 
   it 'returns value of block' do
-    Redis::Mutex.with_lock(:test_lock) { :test_result }.should == :test_result
+    expect(RedisMutex.with_lock(:test_lock) { :test_result }).to eq(:test_result)
   end
 
   it 'requires block for #with_lock' do
-    expect { Redis::Mutex.with_lock(:test_lock) }.to raise_error(LocalJumpError) #=> no block given (yield)
+    expect { RedisMutex.with_lock(:test_lock) }.to raise_error(LocalJumpError) #=> no block given (yield)
   end
 
   it 'raises LockError if lock not obtained' do
-    expect { Redis::Mutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to_not raise_error
-    expect { Redis::Mutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to raise_error(Redis::Mutex::LockError)
+    expect { RedisMutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to_not raise_error
+    expect { RedisMutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to raise_error(RedisMutex::LockError)
   end
 
   it 'raises UnlockError if lock not obtained' do
-    mutex = Redis::Mutex.new(:test_lock)
-    mutex.lock.should be_true
-    mutex.unlock.should be_true
-    expect { mutex.unlock! }.to raise_error(Redis::Mutex::UnlockError)
+    mutex = RedisMutex.new(:test_lock)
+    expect(mutex.lock).to be_truthy
+    expect(mutex.unlock).to be_truthy
+    expect { mutex.unlock! }.to raise_error(RedisMutex::UnlockError)
   end
 
   it 'raises AssertionError when block is given to #lock' do
     # instance method
-    mutex = Redis::Mutex.new(:test_lock)
-    expect { mutex.lock {} }.to raise_error(Redis::Mutex::AssertionError)
+    mutex = RedisMutex.new(:test_lock)
+    expect { mutex.lock {} }.to raise_error(RedisMutex::AssertionError)
 
     # class method
-    expect { Redis::Mutex.lock(:test_lock) {} }.to raise_error(Redis::Mutex::AssertionError)
+    expect { RedisMutex.lock(:test_lock) {} }.to raise_error(RedisMutex::AssertionError)
   end
 
   it 'sweeps expired locks' do
-    Redis::Mutex.set(:past, Time.now.to_f - 60)
-    Redis::Mutex.set(:present, Time.now.to_f)
-    Redis::Mutex.set(:future, Time.now.to_f + 60)
-    Redis::Mutex.keys.size.should == 3
-    Redis::Mutex.sweep.should == 2
-    Redis::Mutex.keys.size.should == 1
-  end
-
-  describe Redis::Mutex::Macro do
-    it 'adds auto_mutex' do
-      t1 = Thread.new { C.new.run_singularly(1).should == "success: 1" }
-      # In most cases t1 wins, but make sure to give it a head start,
-      # not exceeding the sleep inside the method.
-      sleep 0.01
-      t2 = Thread.new { C.new.run_singularly(2).should == "failure: 2" }
-      t1.join
-      t2.join
+    RedisMutex.on(:past).set(Time.now.to_f - 60)
+    RedisMutex.on(:present).set(Time.now.to_f)
+    RedisMutex.on(:future).set(Time.now.to_f + 60)
+    expect(RedisMutex.keys.size).to eq(3)
+    expect(RedisMutex.sweep).to eq(2)
+    expect(RedisMutex.keys.size).to eq(1)
+  end
+
+  describe 'stress test' do
+    LOOP_NUM = 1000
+
+    def run(id)
+      print "invoked worker #{id}...\n"
+      mutex = RedisMutex.new(:test_lock, :expire => 1, :block => 10, :sleep => 0.01)
+      result = 0
+      LOOP_NUM.times do |i|
+        mutex.with_lock do
+          result += 1
+          sleep rand/100
+        end
+      end
+      print "result for worker #{id}: #{result} successful locks\n"
+      exit!(result == LOOP_NUM)
+    end
+
+    it 'runs without hiccups' do
+      begin
+        STDOUT.sync = true
+        puts "\nrunning stress tests..."
+        if pid1 = fork
+          # Parent
+          if pid2 = fork
+            # Parent
+            Process.waitall
+          else
+            # Child 2
+            run(2)
+          end
+        else
+          # Child 1
+          run(1)
+        end
+        STDOUT.flush
+      rescue NotImplementedError
+        puts $!
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -6,9 +6,8 @@ require 'redis-mutex'
 
 RSpec.configure do |config|
   # Use database 15 for testing so we don't accidentally step on you real data.
-  Redis::Classy.db = Redis.new(:db => 15)
-  unless Redis::Classy.keys.empty?
-    puts '[ERROR]: Redis database 15 not empty! If you are sure, run "rake flushdb" beforehand.'
-    exit!
+  RedisClassy.redis = Redis.new(db: 15)
+  unless RedisClassy.keys.empty?
+    abort '[ERROR]: Redis database 15 not empty! If you are sure, run "rake flushdb" beforehand.'
   end
 end

metadata

@@ -1,80 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: redis-mutex
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 2.1.0
+  version: 4.0.2
 platform: ruby
 authors:
 - Kenn Ejima
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-01-11 00:00:00.000000000 Z
+date: 2020-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.2'
-    none: false
-  prerelease: false
   name: redis-classy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
-    none: false
+        version: '2.0'
   type: :runtime
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  prerelease: false
+        version: '2.0'
+- !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
+- !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
-- !ruby/object:Gem::Dependency
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
+- !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Distrubuted mutex using Redis
 email:
 - kenn.ejima@gmail.com
@@ -82,49 +73,43 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/redis-mutex.rb
-- lib/redis/mutex.rb
-- lib/redis/mutex/macro.rb
+- lib/redis_mutex.rb
+- lib/redis_mutex/macro.rb
 - redis-mutex.gemspec
+- spec/redis_mutex_macro_spec.rb
 - spec/redis_mutex_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/kenn/redis-mutex
 licenses: []
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4158529389064232866
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4158529389064232866
-  none: false
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
 summary: Distrubuted mutex using Redis
 test_files:
+- spec/redis_mutex_macro_spec.rb
 - spec/redis_mutex_spec.rb
 - spec/spec_helper.rb

data/lib/redis/mutex.rb

@@ -1,130 +0,0 @@
-class Redis
-  #
-  # Options
-  #
-  # :block  => Specify in seconds how long you want to wait for the lock to be released. Speficy 0
-  #            if you need non-blocking sematics and return false immediately. (default: 1)
-  # :sleep  => Specify in seconds how long the polling interval should be when :block is given.
-  #            It is recommended that you do NOT go below 0.01. (default: 0.1)
-  # :expire => Specify in seconds when the lock should forcibly be removed when something went wrong
-  #            with the one who held the lock. (default: 10)
-  #
-  class Mutex < Redis::Classy
-    autoload :Macro, 'redis/mutex/macro'
-
-    DEFAULT_EXPIRE = 10
-    LockError = Class.new(StandardError)
-    UnlockError = Class.new(StandardError)
-    AssertionError = Class.new(StandardError)
-
-    def initialize(object, options={})
-      super(object.is_a?(String) || object.is_a?(Symbol) ? object : "#{object.class.name}:#{object.id}")
-      @block = options[:block] || 1
-      @sleep = options[:sleep] || 0.1
-      @expire = options[:expire] || DEFAULT_EXPIRE
-    end
-
-    def lock
-      self.class.raise_assertion_error if block_given?
-      @locking = false
-
-      if @block > 0
-        # Blocking mode
-        start_at = Time.now
-        while Time.now - start_at < @block
-          @locking = true and break if try_lock
-          sleep @sleep
-        end
-      else
-        # Non-blocking mode
-        @locking = try_lock
-      end
-      @locking
-    end
-
-    def try_lock
-      now = Time.now.to_f
-      @expires_at = now + @expire                       # Extend in each blocking loop
-      return true   if setnx(@expires_at)               # Success, the lock has been acquired
-      return false  if get.to_f > now                   # Check if the lock is still effective
-
-      # The lock has expired but wasn't released... BAD!
-      return true   if getset(@expires_at).to_f <= now   # Success, we acquired the previously expired lock
-      return false  # Dammit, it seems that someone else was even faster than us to remove the expired lock!
-    end
-
-    # Returns true if resource is locked. Note that nil.to_f returns 0.0
-    def locked?
-      get.to_f > Time.now.to_f
-    end
-
-    def unlock(force = false)
-      # Since it's possible that the operations in the critical section took a long time,
-      # we can't just simply release the lock. The unlock method checks if @expires_at
-      # remains the same, and do not release when the lock timestamp was overwritten.
-
-      if get == @expires_at.to_s or force
-        # Redis#del with a single key returns '1' or nil
-        !!del
-      else
-        false
-      end
-    end
-
-    def with_lock
-      if lock!
-        begin
-          @result = yield
-        ensure
-          unlock
-        end
-      end
-      @result
-    end
-
-    def lock!
-      lock or raise LockError, "failed to acquire lock #{key.inspect}"
-    end
-
-    def unlock!(force = false)
-      unlock(force) or raise UnlockError, "failed to release lock #{key.inspect}"
-    end
-
-    class << self
-      def sweep
-        return 0 if (all_keys = keys).empty?
-
-        now = Time.now.to_f
-        values = mget(*all_keys)
-
-        expired_keys = all_keys.zip(values).select do |key, time|
-          time && time.to_f <= now
-        end
-
-        expired_keys.each do |key, _|
-          # Make extra sure that anyone haven't extended the lock
-          del(key) if getset(key, now + DEFAULT_EXPIRE).to_f <= now
-        end
-
-        expired_keys.size
-      end
-
-      def lock(object, options = {})
-        raise_assertion_error if block_given?
-        new(object, options).lock
-      end
-
-      def lock!(object, options = {})
-        new(object, options).lock!
-      end
-
-      def with_lock(object, options = {}, &block)
-        new(object, options).with_lock(&block)
-      end
-
-      def raise_assertion_error
-        raise AssertionError, 'block syntax has been removed from #lock, use #with_lock instead'
-      end
-    end
-  end
-end

data/lib/redis/mutex/macro.rb

@@ -1,50 +0,0 @@
-class Redis
-  class Mutex
-    module Macro
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_eval do
-          class << self
-            attr_accessor :auto_mutex_methods
-          end
-          @auto_mutex_methods = {}
-        end
-      end
-
-      module ClassMethods
-        def auto_mutex(target, options={})
-          self.auto_mutex_methods[target] = options
-        end
-
-        def method_added(target)
-          return if target.to_s =~ /^auto_mutex_methods/
-          return unless self.auto_mutex_methods[target]
-          without_method  = "#{target}_without_auto_mutex"
-          with_method     = "#{target}_with_auto_mutex"
-          after_method    = "#{target}_after_failure"
-          return if method_defined?(without_method)
-          options = self.auto_mutex_methods[target]
-
-          if options[:after_failure].is_a?(Proc)
-            define_method(after_method, &options[:after_failure])
-          end
-
-          define_method(with_method) do |*args|
-            key = self.class.name << '#' << target.to_s
-
-            begin
-              Redis::Mutex.with_lock(key, options) do
-                send(without_method, *args)
-              end
-            rescue Redis::Mutex::LockError
-              send(after_method, *args) if respond_to?(after_method)
-            end
-          end
-
-          alias_method without_method, target
-          alias_method target, with_method
-        end
-      end
-    end
-  end
-end