mario-redis-lock 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95b3e9086bb1024011a80e88878afff422e0fc5a
+  data.tar.gz: 0c44db03346780a1c8ad274f59978ef4e0f985f4
+SHA512:
+  metadata.gz: 5e5b5faed6e289c517d75b30652b817f30ff89bc4560645b59129cdfab7ecdec3b14ec01f8fe46131d1f5b1c6ee02b18eaa853966a9bb534cd5df07824753915
+  data.tar.gz: 2c4f6b91b32b0881074a76d0e6679c40bd18b098a9cdb7fd9b7b712d7a0697a9d5e8ad0aed44f8245ddb272607ec0e1ecfd5f8355e35109134139a86e9c00681

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mario-redis-lock.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Mario Izquierdo
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,234 @@
+# RedisLock
+
+Yet another distributed lock for Ruby using Redis, with emphasis in the documentation.
+
+
+## Why another redis lock gem?
+
+Other redis locks for ruby: [redis-mutex](https://rubygems.org/gems/redis-mutex), [mlanett-redis-lock](https://rubygems.org/gems/mlanett-redis-lock), [redis-lock](https://rubygems.org/gems/redis-lock), [jashmenn-redis-lock](https://rubygems.org/gems/jashmenn-redis-lock), [ruby_redis_lock](https://rubygems.org/gems/ruby_redis_lock), [robust-redis-lock](https://rubygems.org/gems/robust-redis-lock), [bfg-redis-lock](https://rubygems.org/gems/bfg-redis-lock), etc.
+
+Looking at those other gems I realized that it was not easy to know what was exactly going on with the locks. Then I made this one to be simple but explicit, to be used with confidence in my high scale production applications.
+
+
+## Installation
+
+Requirements:
+
+  * [Redis](http://redis.io/) >= 2.6.12
+  * [redis gem](https://rubygems.org/gems/redis) >= 3.0.5
+
+The required versions are because I use the new syntax for the SET command to easily implement the robust algorithm described in the [SET command documentation](http://redis.io/commands/set).
+
+To install with bundler, add this line to your application's Gemfile:
+
+    gem 'mario-redis-lock'
+
+Ot install it yourself as:
+
+    $ gem install mario-redis-lock
+
+
+## Usage
+
+Acquire the lock to do "exclusive stuff":
+
+```ruby
+RedisLock.adquire do |lock|
+  if lock.acquired?
+    do_exclusive_stuff # you are the one with the lock, hooray!
+  else
+    oh_well # someone else has the lock
+  end
+end
+```
+
+Or (equivalent)
+
+
+```ruby
+lock = RedisLock.new
+if lock.acquire
+  begin
+    do_exclusive_stuff # you are the one with the lock, hooray!
+  ensure
+    lock.release
+  end
+else
+  oh_well # someone else has the lock
+end
+```
+
+The class method `RedisLock.adquire(options, &block)` is more concise and releases the lock at the end of the block, even if `do_exclusive_stuff` raises an exception.
+But the second alternative is a little more flexible.
+
+
+### Options
+
+  * **redis**: (default `Redis.new`) an instance of Redis, or an options hash to initialize an instance of Redis (see [redis gem](https://rubygems.org/gems/redis)). You can also pass anything that "quaks" like redis, for example an instance of [mock_redis](https://rubygems.org/gems/mock_redis), for testing purposes.
+  * **key**: (default `"RedisLock::default"`) Redis key used for the lock. If you need multiple locks, use a different (unique) key for each lock.
+  * **autorelease**: (default `10.0`) seconds to automatically release (expire) the lock after being acquired. Make sure to give enough time for your "exclusive stuff" to be executed, otherwise other processes could get the lock and start messing with the "exclusive stuff" before this one is done. The autorelease time is important, even when manually doing `lock.realease`, because the process could crash before releasing the lock. Autorelease (expiration time) guarantees that the lock will always be released.
+  * **retry**: (default `true`) boolean to enable/disable consecutive acquire retries in the same `acquire` call. If true, use `retry_timeout` and `retry_sleep` to specify how long and hot often should the `acquire` method be blocking the thread until is able to get the lock.
+  * **retry_timeout**: (default `10.0`) time in seconds to specify how long should this thread be waiting for the lock to be released. Note that the execution thread is put to sleep while waiting. For a non-blocking approach, set `retry` to false.
+  * **retry_sleep**: (default `0.1`) seconds to sleep between retries. For example: `RedisLock.adquire(retry_timeout: 10.0, retry_sleep: 0.1) do |lock|`, in the worst case scenario, will do 99 or 100 retries (one every 100 milliseconds, plus a little extra for the acquire attempt) during 10 seconds, and finally yield with `lock.acquired? == false`.
+
+Configure the default values with `RedisLock.configure`:
+
+```ruby
+RedisLock.configure do |defaults|
+  defaults.redis = Redis.new
+  defaults.key = "RedisLock::default"
+  defaults.autorelease = 10.0
+  defaults.retry = true
+  defaults.retry_timeout = 10.0
+  defaults.retry_sleep = 0.1
+end
+```
+
+A good place to set defaults in a Rails app would be in an initializer `conf/initializers/redis_lock.rb`.
+
+Options can be set to other than the defaults when calling `RedisLock.acquire`:
+
+```ruby
+RedisLock.acquire(key: 'exclusive_stuff', retry: false) do |lock|
+  if lock.acquired?
+    do_exclusive_stuff
+  end
+end
+```
+
+Or when creating a new lock instance:
+
+```ruby
+lock = RedisLock.new(key: 'exclusive_stuff', retry: false)
+if lock.acquire
+  begin
+    do_exclusive_stuff
+  ensure
+    lock.release
+  end
+end
+```
+
+### Example: Shared Photo Booth that can only take one photo at a time
+
+If we have a `PhotoBooth` shared resource, we can use a `RedisLock` to ensure it is used only by one thread at a time:
+
+```ruby
+require 'redis_lock'
+require 'photo_booth' # made up shared resource
+
+RedisLock.configure do |c|
+  c.redis = {url: "redis://:p4ssw0rd@10.0.1.1:6380/15"}
+  c.key   = 'photo_booth_lock'
+
+  c.autorelease   = 60 # assume it never takes more than one minute to make a picture
+  c.retry_timeout = 300 # retry for 5 minutes
+  c.retry_sleep   = 1   # retry once every second
+end
+
+RedisLock.acquire do |lock|
+  if lock.acquired?
+    PhotoBooth.take_photo
+  else
+    raise "I'm bored of waiting and I'm getting out"
+  end
+end
+```
+
+This script can be executed from many different places at the same time, as far as they have access to the shared PhotoBooth and Redis instances. Only one photo will be taken at a time.
+Note that the options `autorelease`, `retry_timeout` and `retry_sleep` should be tuned differently depending on the frequency of the operation and the known speed of the `PhotoBooth.take_photo` operation.
+
+
+### Example: Avoid the Dog-Pile effec when invalidating some cached value
+
+The Dog-Pile effect is a specific case of the [Thundering Herd problem](http://en.wikipedia.org/wiki/Thundering_herd_problem),
+that happens when a cached value expires and suddenly too many threads try to calculate the new value at the same time.
+
+Sometimes, the calculation takes expensive resources and it is just fine to do it from just one thread.
+
+Assume you have a simple cache, a `fetch` function that uses a redis instance.
+
+Without the lock:
+
+```ruby
+# Retrieve the cached value from the redis key.
+# If the key is not available, execute the block
+# and store the new calculated value in the redis key with an expiration time.
+def fetch(redis, key, expire, &block)
+  val = redis.get(key)
+  if not val
+    val = block.call
+    redis.setex(key, expire, val) unless val.nil? # do not set anything if the value is nil
+  end
+  val
+end
+```
+
+Whith this method, it is easy to optimize slow operations by caching them in Redis.
+For example, if you want to do a `heavy_database_query`:
+
+```ruby
+require 'redis'
+redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
+
+val = fetch redis, 'heavy_query', 10 do
+  heavy_database_query # Recalculate if not cached (SLOW)
+end
+
+puts val
+```
+
+But this fetch could block the database if executed from too many threads, because when the Redis key expires all of them will do the `heavy_database_query` at the same time.
+
+Avoid this problem with a `RedisLock`:
+
+```ruby
+require 'redis'
+require 'redis_lock'
+redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
+
+RedisLock.configure do |c|
+  c.redis = redis
+  c.key = 'heavy_query_lock'
+  c.autorelease = 20 # assume it never takes more than 20 seconds to do the slow query
+  c.retry = false # try to acquire only once, if the lock is already taken then the new value should be cached again soon
+end
+
+def fetch_with_lock(retries = 10)
+  val = fetch redis, 'heavy_query', 10 do
+    # If we need to recalculate val,
+    # use a lock to make sure that heavy_database_query is only done by one process
+    RedisLock.acquire do |lock|
+      if lock.acquired?
+        heavy_database_query
+      else
+        nil # do not store in cache and return val = nil
+      end
+    end
+  end
+
+  # Try again if cache miss, and the lock was acquired by other process.
+  if val.nil? and retries > 0
+    fetch_with_lock(retries - 1)
+  else
+    val
+  end
+end
+
+val = fetch_with_lock()
+puts val
+```
+
+In this case, the script could be executed from as many threads as we want at the same time, because the heavy_database_query is done only once while the other threads wait until the value is cached again or the lock is released.
+
+
+## Contributing
+
+1. Fork it ( http://github.com/marioizquierdo/redis-lock/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Make sure you have installed Redis in localhost:6379. The DB 15 will be used for tests (and flushed after every test).
+There is a rake task to play with an example: `rake smoke_and_pass`

data/Rakefile

@@ -0,0 +1,74 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc 'Flush the test database (15)'
+task :flushdb do
+  redis_test_db.flushdb
+end
+
+desc 'Test app: The lock is the joint, only one thread can smoke at a time'
+task :smoke_and_pass do
+  threads = (ENV['threads'] || 6).to_i
+  puts "The big smoke starts with #{threads} threads"
+  puts "Use ctr+c to EXIT"
+
+  RedisLock.configure do |conf|
+    conf.redis = redis_test_db
+    conf.key = 'the_joint'
+    conf.autorelease = 0.6
+    conf.retry_timeout = 0.5
+    conf.retry_sleep = 0.1
+  end
+
+  ts = []
+  threads.times do |i|
+    ts << Thread.new do
+      smoker(i)
+    end
+  end
+
+  ts.each do |t|
+    t.join
+  end
+end
+
+def smoker(id)
+  loop do
+    color_puts id, "         Thread##{id} wants to smoke"
+    lock = RedisLock.new
+    if lock.acquire
+      color_puts id, "joint >> Thread##{id} grabs the joint from the table"
+      sleep (rand < 0.5 ? 0.3 : 0.4) # SMOKE for 0.3 or 0.4 seconds
+      if rand < 0.1
+        color_puts id, "CRASH!!! Thread##{id} DIED while smoking. The joint will come back to the table when autoreleased"
+        break
+      else
+        color_puts id, "      << Thread##{id} returs the joint to the table\n"
+        lock.release
+      end
+
+    else
+      color_puts id, "      !! Thread##{id} could not get the joint. Try again later"
+    end
+
+    sleep 0.3 + rand(4).to_f/10 # WAIT for next try
+  end
+end
+
+# Wrap text with ANSI colors
+def color_puts(id, text)
+  if id < 10
+    print "\033[0;3#{id+1}m#{text}\033[0m\n"
+  else
+    print "#{text}\n"
+  end
+end
+
+def redis_test_db
+  require 'redis'
+  @redis_test_db ||= Redis.new(db: 15)
+end

data/lib/redis_lock.rb

@@ -0,0 +1,125 @@
+require 'redis' # redis gem required
+require 'securerandom' # SecureRandom (from stdlib)
+
+class RedisLock
+
+  # Gem version
+  VERSION = "1.0.0"
+
+  # Original defaults
+  DEFAULT_ATTRS = {
+    redis: nil, # Redis instance with defaults
+    key: 'RedisLock::default', # Redis key to store the lock
+    autorelease: 10.0, # seconds to expire
+    retry: true, # false to only try to acquire once
+    retry_timeout: 10.0, # max number of seconds to keep doing retries if the lock is not available
+    retry_sleep: 0.1 # seconds to sleep before the nex retry
+  }
+
+  # Attributes
+  DEFAULT_ATTRS.keys.each do |attr|
+    attr_accessor attr
+  end
+  attr_accessor :acquired_token # if the lock was successfully acquired, this is the token used to identify the lock. False otherwise.
+  attr_accessor :last_acquire_retries # info about how many times had to retry to acquire the lock on the last call to acquire. First try counts as 0
+
+  # Restore original defaults
+  def self.configure_restore_defaults
+    @@config = Struct.new(*DEFAULT_ATTRS.keys).new(*DEFAULT_ATTRS.values)
+  end
+  self.configure_restore_defaults # apply defaults
+
+  # Configure defaults
+  def self.configure
+    yield @@config
+  end
+
+  # Acquire a lock. Use options to override defaults.
+  # This method makes sure to release the lock as soon as the block is finalized.
+  def self.acquire(opts={}, &block)
+    lock = RedisLock.new(opts)
+    if lock.acquire
+      begin
+        block.call(lock)
+      ensure
+        lock.release
+      end
+    else
+      block.call(lock)
+    end
+  end
+
+  def initialize(opts={})
+    # Check if options are valid
+    allowed_opts = DEFAULT_ATTRS.keys
+    invalid_opts = opts.keys - allowed_opts
+    raise ArgumentError.new("Invalid options: #{invalid_opts.inspect}. Please use one of #{allowed_opts.inspect} ") unless invalid_opts.empty?
+
+    # Set attributes from options or defaults
+    self.redis = opts[:redis] || @@config.redis || Redis.new
+    self.redis = Redis.new(redis) if redis.is_a? Hash # allow to use Redis options instead of a redis instance
+    self.key           = opts[:key] || @@config.key
+    self.autorelease   = opts[:autorelease] || @@config.autorelease
+    self.retry         = opts.include?(:retry) ? opts[:retry] : @@config.retry
+    self.retry_timeout = opts[:retry_timeout] || @@config.retry_timeout
+    self.retry_sleep   = opts[:retry_sleep] || @@config.retry_sleep
+  end
+
+  # Try to acquire the lock.
+  # Retrun true on success, false on failure (someone else has the lock)
+  def acquire
+    @first_try_time ||= Time.now
+    @token ||= SecureRandom.uuid # token is used to make sure that we own the lock when releasing it
+    @retries ||= 0
+
+    # Lock using a redis key, if not exists (NX) with an expiration time (EX).
+    # NOTE that the NX and EX options are not supported by REDIS versions older than 2.6.12
+    # See lock pattern: http://redis.io/commands/SET
+    expire = (autorelease * 1000).to_i # to milliseconds
+    if redis.set(key, @token, nx: true, px: expire)
+      self.acquired_token = @token # assign acquired_token
+
+    else
+      self.acquired_token = nil # clear acquired_token, to make the acquired? method return false
+
+      # Wait and try again if retry option is set and didn't timeout
+      if self.retry and (Time.now - @first_try_time) < retry_timeout
+        sleep retry_sleep # wait
+        @retries += 1
+        return acquire # and try again
+      end
+    end
+
+    self.last_acquire_retries = @retries
+    @retries = nil # reset retries
+    @first_try_time = nil # reset timestamp
+
+    return self.acquired?
+  end
+
+  # Release the lock.
+  # Returns a Symbol with the status of the operation:
+  #   * :success if properly released
+  #   * :already_released if the lock was already released or expired (other process could be using it now)
+  #   * :not_acquired if the lock was not acquired (no release action was made because it was not needed)
+  def release
+    if acquired?
+      script = 'if redis.call("get",KEYS[1]) == ARGV[1] then return redis.call("del",KEYS[1]) else return nil end'
+      ret = redis.eval(script, [key], [self.acquired_token])
+      self.acquired_token = nil # cleanup acquired token
+      if ret == nil
+        :already_released
+      else
+        :success
+      end
+    else
+      :not_acquired
+    end
+  end
+
+  # Check if last lock acquisition was successful.
+  # Note that it doesn't track autorelease, if the lock is naturally expired, this value will still be true.
+  def acquired?
+    !!self.acquired_token # acquired_token is only set on success
+  end
+end

data/mario-redis-lock.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'redis_lock'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mario-redis-lock"
+  spec.version       = RedisLock::VERSION
+  spec.authors       = ["Mario Izquierdo"]
+  spec.email         = ["tomario@gmail.com"]
+  spec.summary       = %q{Yet another distributed lock for Ruby using Redis.}
+  spec.description   = %q{Yet another distributed lock for Ruby using Redis, with emphasis in the documentation. Requires Redis >= 2.6.12, because it uses the new syntax for SET to easily implement the robust algorithm described in the SET command documentation (http://redis.io/commands/set).}
+  spec.homepage      = "https://github.com/marioizquierdo/mario-redis-lock"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'redis', '>= 3.0.5' # Needed support for SET with EX, PX, NX, XX options: https://github.com/redis/redis-rb/pull/343
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/spec/redis_lock_spec.rb

@@ -0,0 +1,247 @@
+require 'minitest'
+require 'minitest/autorun'
+require 'redis'
+require_relative '../lib/redis_lock'
+
+# Use local redis db 15 for tests
+REDIS = Redis.new(db: 15)
+unless REDIS.keys.empty?
+  puts '[ERROR]: Redis database 15 will be used for tests but is not empty! If you are sure, run "rake flushdb" beforehand.'
+  exit!
+end
+
+describe RedisLock do
+  before do
+    REDIS.flushdb # cleanup redis
+    RedisLock.configure do |conf|
+      conf.redis = REDIS # use test Redis instance
+      conf.retry = false # do not retry by default, is more convenient for fast tests
+    end
+  end
+
+  after do
+    RedisLock.configure_restore_defaults # restore defaults
+  end
+
+  Minitest.after_run do
+    REDIS.flushdb # cleanup redis
+  end
+
+
+  describe "configure" do
+    it "changes the defaults" do
+      RedisLock.configure do |conf|
+        conf.key = "mykey"
+        conf.autorelease = 11
+        conf.retry = true
+        conf.retry_timeout = 11
+        conf.retry_sleep = 11
+      end
+      lock = RedisLock.new
+      lock.key.must_equal "mykey"
+      lock.autorelease.must_equal 11
+      lock.retry.must_equal true
+      lock.retry_timeout.must_equal 11
+      lock.retry_sleep.must_equal 11
+    end
+    it "raises an error if setting an invalid option" do
+      proc do
+        RedisLock.configure do |conf|
+          conf.nonexistingattr = "blabla"
+        end
+      end.must_raise NoMethodError
+    end
+  end
+
+  describe "acquire" do
+    describe "with bad redis connection" do
+      it "raises a Redis::CannotConnectError" do
+        proc { RedisLock.acquire(redis: {url: "redis://localhost:1111/15"}){|l| }}.must_raise Redis::CannotConnectError
+      end
+    end
+
+    it "holds the lock" do
+      RedisLock.acquire do |lock|
+        lock.acquired?.must_equal true
+        RedisLock.acquire do |lock|
+          lock.acquired?.must_equal false
+        end
+      end
+    end
+    it "releases the lock at the end of the block" do
+      RedisLock.acquire do |lock|
+        lock.acquired?.must_equal true
+      end
+      RedisLock.acquire do |lock|
+        lock.acquired?.must_equal true
+      end
+    end
+    it "overrides the default config with passed options" do
+      RedisLock.acquire(key: 'override', autorelease: 5555) do |lock|
+        lock.key.must_equal 'override'
+        lock.autorelease.must_equal 5555
+      end
+    end
+  end
+
+  describe "initialize" do
+    it "uses conf as default values" do
+      RedisLock.configure do |conf|
+        conf.key = "mykey"
+        conf.autorelease = 111
+      end
+      lock = RedisLock.new
+      lock.key.must_equal "mykey"
+      lock.autorelease.must_equal 111
+    end
+    it "uses options to set values different than the defaults" do
+      RedisLock.configure do |conf|
+        conf.key = "mykey"
+        conf.autorelease = 111
+      end
+      lock = RedisLock.new(key: 'override', autorelease: 5555)
+      lock.key.must_equal 'override'
+      lock.autorelease.must_equal 5555
+    end
+    it "initializes a lock that is not acquired" do
+      lock = RedisLock.new
+      lock.acquired?.must_equal false
+    end
+    it "raises an ArgumentError if using invalid options" do
+      proc do
+        RedisLock.new(nonexistingattr: "blabla")
+      end.must_raise ArgumentError
+    end
+  end
+
+  describe "#acquire" do
+    describe "with bad redis connection" do
+      it "raises a Redis::CannotConnectError" do
+        proc do
+          lock = RedisLock.new(redis: {url: "redis://localhost:1111/15"})
+          lock.acquire
+        end.must_raise Redis::CannotConnectError
+      end
+    end
+
+    it "holds the lock and returs true if acquired" do
+      lock1 = RedisLock.new
+      lock1.acquire.must_equal true
+      lock1.acquired?.must_equal true
+
+      lock2 = RedisLock.new
+      lock2.acquire.must_equal false # already acquired by lock1
+      lock2.acquired?.must_equal false
+    end
+
+    it "holds the lock in the specified key" do
+      RedisLock.new(key: 'key1').acquire.must_equal true
+      RedisLock.new(key: 'key1').acquire.must_equal false # same key1, already in use
+      RedisLock.new(key: 'key2').acquire.must_equal true # key2 is free
+      RedisLock.new(key: 'key2').acquire.must_equal false # but not anymore
+    end
+
+    it "sets autorelease expiration time" do
+      RedisLock.configure do |conf|
+        conf.autorelease = 0.005
+      end
+
+      RedisLock.new.acquire.must_equal true
+      RedisLock.new.acquire.must_equal false # already acquired
+      sleep 0.010
+      RedisLock.new.acquire.must_equal true # autoreleased
+      RedisLock.new.acquire.must_equal false # already acquired
+      RedisLock.new.acquire.must_equal false # already acquired
+      sleep 0.010
+      RedisLock.new.acquire.must_equal true # autoreleased again
+    end
+
+    it "retries with retry, retry_timeout and retry_sleep" do
+      RedisLock.new.acquire # locked to make next acquisitions fail, to force them use the retries
+
+      # No retries if retry: false
+      lock = RedisLock.new(retry: false)
+      lock.acquire.must_equal false
+      lock.last_acquire_retries.must_equal 0
+
+      # Number of retries depends on retry_sleep
+      lock = RedisLock.new(retry: true, retry_timeout: 0.03, retry_sleep: 0.01)
+      lock.acquire.must_equal false
+      lock.last_acquire_retries.must_be_within_delta 2, 1 # it should around 1..3 retries
+
+      # Number with less retry_sleep time, there should be more retries
+      lock = RedisLock.new(retry: true, retry_timeout: 0.03, retry_sleep: 0.001)
+      lock.acquire.must_equal false
+      lock.last_acquire_retries.must_be_within_delta 20, 10 # it should around 10..30 retries
+
+      # retry_timeout stops execution
+      time = Time.now
+      lock = RedisLock.new(retry: true, retry_timeout: 0.03, retry_sleep: 0.01) # small retry_sleep should allow for many more retries
+      lock.acquire.must_equal false
+      (Time.now - time).must_be_within_delta 0.03, 0.01
+
+      # If the lock becomes available, it stops retrying
+      time = Time.now
+      lock = RedisLock.new(key: 'key2', autorelease: 0.03)
+      lock.acquire.must_equal true
+      lock2 = RedisLock.new(key: 'key2', retry: true, retry_timeout: 1, retry_sleep: 0.01)
+      lock2.acquire.must_equal true # it was able to get it after it was autoreleased
+      lock2.last_acquire_retries.must_be_within_delta 2, 1 # only a few retries because it was available righ after expired
+      (Time.now - time).must_be_within_delta 0.03, 0.01
+    end
+  end
+
+  describe "#release" do
+    it 'releases the lock and returns :success' do
+      lock  = RedisLock.new
+      lock2 = RedisLock.new
+
+      lock.acquire.must_equal true
+      lock2.acquire.must_equal false
+
+      lock.release.must_equal :success
+      lock2.acquire.must_equal true
+      lock.acquire.must_equal false
+
+      lock2.release.must_equal :success
+      lock.acquire.must_equal true
+    end
+
+    it 'returns :not_acquired if the lock is not acquired first' do
+      lock  = RedisLock.new
+      lock.acquired?.must_equal false
+      lock.release.must_equal :not_acquired
+      lock.acquire.must_equal true
+      lock.acquired?.must_equal true
+      lock.release.must_equal :success
+      lock.acquired?.must_equal false
+      lock.release.must_equal :not_acquired # we don't hold the lock anymore
+    end
+
+    it 'returns :already_released if the lock expired before releasing it' do
+      lock = RedisLock.new(autorelease: 0.001)
+      lock.acquire.must_equal true
+      sleep 0.002
+      lock.release.must_equal :already_released
+      lock.acquired?.must_equal false
+    end
+
+    it 'returns :already_released if the lock expired, and does not remove it from any process that might be using the lock' do
+      lock = RedisLock.new(autorelease: 0.001)
+      lock.acquire.must_equal true
+      sleep 0.002
+      lock2 = RedisLock.new
+      lock2.acquire.must_equal true # now the lock is owned by lock2
+
+      lock.release.must_equal :already_released # lock releases
+      lock.acquired?.must_equal false
+
+      lock2.acquired?.must_equal true # but lock2 still holds the lock
+      RedisLock.new.acquire.must_equal false
+      RedisLock.new.acquire.must_equal false # that is why the lock can not be acquired by others
+
+      lock2.release.must_equal :success # once lock2 releases
+      RedisLock.new.acquire.must_equal true # others can finally get the lock
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: mario-redis-lock
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mario Izquierdo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yet another distributed lock for Ruby using Redis, with emphasis in the
+  documentation. Requires Redis >= 2.6.12, because it uses the new syntax for SET
+  to easily implement the robust algorithm described in the SET command documentation
+  (http://redis.io/commands/set).
+email:
+- tomario@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/redis_lock.rb
+- mario-redis-lock.gemspec
+- spec/redis_lock_spec.rb
+homepage: https://github.com/marioizquierdo/mario-redis-lock
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Yet another distributed lock for Ruby using Redis.
+test_files:
+- spec/redis_lock_spec.rb