redlock 0.1.5 → 0.2.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZWE3MWMxNjdhNDQ5OTE3ZDk4ODM5YTk0YzJhMTdiYmIyZjMzNWNlYg==
-  data.tar.gz: !binary |-
-    ZmQ4YmY4ODEzZDZlOWVmNmZlYzBmMTFiZDIzNjg2NDk1NWYyYmEzZg==
+SHA1:
+  metadata.gz: 8e34b717846f5f8faa005ab9a8d5cac3c3ea865e
+  data.tar.gz: f7a615768b2fc2746d16128122a69259c252b78f
 SHA512:
-  metadata.gz: !binary |-
-    ZTdjMTdkNjZmNDBkNmQyYmIyMmQ4OTJjOTBlNGQxZmNlNGIxY2NlZjY0NTIx
-    NDI1YTRmYTkyYjc4ZDY1OTc3ZmFjODI5Y2UwYzVjYzI1MTcyYmQ0Y2M2MGY3
-    MTAxMDRlMWFmMjcyMjI2ZDExMDU3MTI0ODU0N2UyNjQyMjIwNGM=
-  data.tar.gz: !binary |-
-    ZWI3MzI4NjQzZjEyZGIyMTU0OTA3YTIxMzIxMTFiZjExYzAzNTMwMTgzZDdm
-    OWY5MzFiMWIwOWRhNmUwNzVjY2M5MzI5M2JiMmUyMzUwNjM0MzI0YWYxZWQy
-    Y2ZkZTJkMzdhOWU1OTE0MTFlNTcxZjNmNWMzN2QyZDgzZmZlNmQ=
+  metadata.gz: ced9a5040b0fe2b0d2ea947732495c06a647b8df04cb5cda89b3f82731d76f79446afda7dd86d21b6705c67f6ccfc42f5c44fa16b753d09abd242d590172fe63
+  data.tar.gz: 0ce3c67e5f9b81d2f8381daf9708c728f8ceaa6a3367e3153586c4621748ffcef717595333b184e7da08932be7e023dfab549b78040d064b079d762a173e800b

data/.gitignore

@@ -1,2 +1,3 @@
 *.gem
 coverage/
+.bundle/

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 services:
     - redis-server
 rvm:
-  - "2.0.0"
+  - "2.2.2"
 script: bundle exec rspec spec
 sudo: false
 cache: bundler

data/Gemfile.lock

@@ -1,57 +1,54 @@
 PATH
   remote: .
   specs:
-    redlock (0.1.5)
-      redis (~> 3, >= 3.0.5)
+    redlock (0.2.1)
+      redis (>= 3.0.0, < 5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coveralls (0.7.11)
-      multi_json (~> 1.10)
-      rest-client (>= 1.6.8, < 2)
-      simplecov (~> 0.9.1)
+    coveralls (0.8.19)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.12.0)
       term-ansicolor (~> 1.3)
       thor (~> 0.19.1)
-    diff-lcs (1.2.5)
+      tins (~> 1.6)
+    diff-lcs (1.3)
     docile (1.1.5)
-    mime-types (2.4.3)
-    multi_json (1.11.0)
-    netrc (0.10.3)
-    rake (10.4.2)
-    redis (3.2.2)
-    rest-client (1.7.3)
-      mime-types (>= 1.16, < 3.0)
-      netrc (~> 0.7)
-    rspec (3.2.0)
-      rspec-core (~> 3.2.0)
-      rspec-expectations (~> 3.2.0)
-      rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.2)
-      rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.0)
+    json (2.0.3)
+    rake (11.3.0)
+    redis (4.0.1)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-mocks (3.2.1)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
-    simplecov (0.9.2)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    simplecov (0.12.0)
       docile (~> 1.1.0)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.9.0)
-    simplecov-html (0.9.0)
-    term-ansicolor (1.3.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    term-ansicolor (1.4.0)
       tins (~> 1.0)
-    thor (0.19.1)
-    tins (1.3.5)
+    thor (0.19.4)
+    tins (1.13.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.7)
-  coveralls
-  rake (~> 10.0)
+  coveralls (~> 0.8.13)
+  rake (~> 11.1, >= 11.1.2)
   redlock!
-  rspec (~> 3.1)
+  rspec (~> 3, >= 3.0.0)
+
+BUNDLED WITH
+   1.16.0

data/Makefile

@@ -0,0 +1,4 @@
+default: test
+test:
+	docker-compose run --rm test
+

data/README.md

@@ -8,8 +8,6 @@
 [![Inline docs](http://inch-ci.org/github/leandromoreira/redlock-rb.svg?branch=master)](http://inch-ci.org/github/leandromoreira/redlock-rb)
 [![Join the chat at https://gitter.im/leandromoreira/redlock-rb](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/leandromoreira/redlock-rb?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-[![Codeship](https://codeship.com/projects/901ff180-c1ad-0132-1a88-3eb2295b72b3/status?branch=master)](https://codeship.com/projects/901ff180-c1ad-0132-1a88-3eb2295b72b3/status?branch=master)
-
 
 # Redlock - A ruby distributed lock using redis.
 
@@ -19,6 +17,10 @@
 
 This is an implementation of a proposed [distributed lock algorithm with Redis](http://redis.io/topics/distlock). It started as a fork from [antirez implementation.](https://github.com/antirez/redlock-rb)
 
+## Compatibility
+
+Redlock works with Redis versions 2.6 or later.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -91,15 +93,58 @@ rescue Redlock::LockError
 end
 ```
 
+To extend the life of the lock:
+
+```ruby
+begin
+  block_result = lock_manager.lock!("resource_key", 2000) do |lock_info|
+    # critical code
+    lock_manager.lock("resource key", 3000, extend: lock_info)
+    # more critical code
+  end
+rescue Redlock::LockError
+  # error handling
+end
+```
+
+The above code will also acquire the lock if the previous lock has expired and the lock is currently free. Keep in mind that this means the lock could have been acquired by someone else in the meantime. To only extend the life of the lock if currently locked by yourself, use `extend_life` parameter:
+
+```ruby
+begin
+  block_result = lock_manager.lock!("resource_key", 2000) do |lock_info|
+    # critical code
+    lock_manager.lock("resource key", 3000, extend: lock_info, extend_life: true)
+    # more critical code, only if lock was still hold
+  end
+rescue Redlock::LockError
+  # error handling
+end
+```
+
+It's possible to customize the retry logic providing the following options:
+
+```ruby
+  lock_manager = Redlock::Client.new(
+                  servers, {
+                  retry_count:   3,
+                  retry_delay:   200, # milliseconds
+                  retry_jitter:  50,  # milliseconds
+                  redis_timeout: 0.1  # seconds
+                 })
+```
+
+For more information you can check [documentation](http://www.rubydoc.info/gems/redlock/Redlock%2FClient:initialize).
+
+
 ## Run tests
 
-Make sure you have at least 1 redis instances up.
+Make sure you have [docker installed](https://docs.docker.com/engine/installation/).
 
-    $ rspec
+    $ make
 
 ## Disclaimer
 
-This code implements an algorithm which is currently a proposal, it was not formally analyzed. Make sure to understand how it works before using it in your production environments. You can see discussion about this approach at [reddit](http://www.reddit.com/r/programming/comments/2nt0nq/distributed_lock_using_redis_implemented_in_ruby/).
+This code implements an algorithm which is currently a proposal, it was not formally analyzed. Make sure to understand how it works before using it in your production environments. You can see discussion about this approach at [reddit](http://www.reddit.com/r/programming/comments/2nt0nq/distributed_lock_using_redis_implemented_in_ruby/) and also the [Antirez answers](http://antirez.com/news/101) for some critics.
 
 ## Contributing
 

data/clean_docker.sh

@@ -0,0 +1,26 @@
+EXITED=$(docker ps -q -f status=exited)
+DANGLING=$(docker images -q -f "dangling=true")
+DANGLING_VOLUME=$(docker volume ls -qf "dangling=true")
+
+if [ "$1" == "--dry-run" ]; then
+  echo "==> Would stop containers:"
+  echo $EXITED
+  echo "==> And images:"
+  echo $DANGLING
+else
+  if [ -n "$EXITED" ]; then
+    docker rm $EXITED
+  else
+    echo "No containers to remove."
+  fi
+  if [ -n "$DANGLING" ]; then
+    docker rmi $DANGLING
+  else
+    echo "No images to remove."
+  fi
+  if [ -n "$DANGLING_VOLUME" ]; then
+    docker volume rm $DANGLING_VOLUME
+  else
+    echo "No volumes to remove."
+  fi
+fi

data/docker-compose.yml

@@ -0,0 +1,27 @@
+version: '2'
+services:
+  test:
+    image: ruby
+    volumes:
+      - .:/redlock
+    working_dir: /redlock
+    command: bash -c "bundle install && rspec"
+    environment:
+      - REDIS1_HOST=redis1.local.com
+      - REDIS1_PORT=6379
+      - REDIS2_HOST=redis2.local.com
+      - REDIS2_PORT=6379
+      - DEFAULT_REDIS_HOST=redis1.local.com
+      - DEFAULT_REDIS_PORT=6379
+    links:
+      - redis1:redis1.local.com
+      - redis2:redis2.local.com
+    depends_on:
+      - redis1
+      - redis2
+
+  redis1:
+    image: redis
+  redis2:
+    image: redis
+

data/lib/redlock/client.rb

@@ -3,18 +3,22 @@ require 'securerandom'
 
 module Redlock
   class Client
-    DEFAULT_REDIS_URLS    = ['redis://localhost:6379']
+    DEFAULT_REDIS_HOST    = ENV["DEFAULT_REDIS_HOST"] || "localhost"
+    DEFAULT_REDIS_PORT    = ENV["DEFAULT_REDIS_PORT"] || "6379"
+    DEFAULT_REDIS_URLS    = ["redis://#{DEFAULT_REDIS_HOST}:#{DEFAULT_REDIS_PORT}"]
     DEFAULT_REDIS_TIMEOUT = 0.1
     DEFAULT_RETRY_COUNT   = 3
     DEFAULT_RETRY_DELAY   = 200
+    DEFAULT_RETRY_JITTER  = 50
     CLOCK_DRIFT_FACTOR    = 0.01
 
     # Create a distributed lock manager implementing redlock algorithm.
     # Params:
     # +servers+:: The array of redis connection URLs or Redis connection instances. Or a mix of both.
-    # +options+:: You can override the default value for `retry_count` and `retry_delay`.
+    # +options+:: You can override the default value for `retry_count`, `retry_delay` and `retry_gitter`.
     #    * `retry_count`   being how many times it'll try to lock a resource (default: 3)
     #    * `retry_delay`   being how many ms to sleep before try to lock again (default: 200)
+    #    * `retry_jitter`  being how many ms to jitter retry delay (default: 50)
     #    * `redis_timeout` being how the Redis timeout will be set in seconds (default: 0.1)
     def initialize(servers = DEFAULT_REDIS_URLS, options = {})
       redis_timeout = options[:redis_timeout] || DEFAULT_REDIS_TIMEOUT
@@ -25,20 +29,23 @@ module Redlock
           RedisInstance.new(server)
         end
       end
-      @quorum = servers.length / 2 + 1
+      @quorum = (servers.length / 2).to_i + 1
       @retry_count = options[:retry_count] || DEFAULT_RETRY_COUNT
       @retry_delay = options[:retry_delay] || DEFAULT_RETRY_DELAY
+      @retry_jitter = options[:retry_jitter] || DEFAULT_RETRY_JITTER
     end
 
     # Locks a resource for a given time.
     # Params:
     # +resource+:: the resource (or key) string to be locked.
     # +ttl+:: The time-to-live in ms for the lock.
-    # +extend+: A lock ("lock_info") to extend.
+    # +options+:: Hash of optional parameters
+    #  * +extend+: A lock ("lock_info") to extend.
+    #  * +extend_only_if_life+: If +extend+ is given, only acquire lock if currently held
     # +block+:: an optional block to be executed; after its execution, the lock (if successfully
     # acquired) is automatically unlocked.
-    def lock(resource, ttl, extend: nil, &block)
-      lock_info = try_lock_instances(resource, ttl, extend)
+    def lock(resource, ttl, options = {}, &block)
+      lock_info = try_lock_instances(resource, ttl, options)
 
       if block_given?
         begin
@@ -62,10 +69,10 @@ module Redlock
     # Locks a resource, executing the received block only after successfully acquiring the lock,
     # and returning its return value as a result.
     # See Redlock::Client#lock for parameters.
-    def lock!(*args, **keyword_args)
+    def lock!(*args)
       fail 'No block passed' unless block_given?
 
-      lock(*args, **keyword_args) do |lock_info|
+      lock(*args) do |lock_info|
         raise LockError, 'failed to acquire lock' unless lock_info
         return yield
       end
@@ -86,7 +93,7 @@ module Redlock
       # also https://github.com/sbertrang/redis-distlock/issues/2 which proposes the value-checking
       # and @maltoe for https://github.com/leandromoreira/redlock-rb/pull/20#discussion_r38903633
       LOCK_SCRIPT = <<-eos
-        if redis.call("exists", KEYS[1]) == 0 or redis.call("get", KEYS[1]) == ARGV[1] then
+        if (redis.call("exists", KEYS[1]) == 0 and ARGV[3] == "yes") or redis.call("get", KEYS[1]) == ARGV[1] then
           return redis.call("set", KEYS[1], ARGV[1], "PX", ARGV[2])
         end
       eos
@@ -95,15 +102,15 @@ module Redlock
         if connection.respond_to?(:client)
           @redis = connection
         else
-          @redis  = Redis.new(connection)
+          @redis = Redis.new(connection)
         end
 
         load_scripts
       end
 
-      def lock(resource, val, ttl)
+      def lock(resource, val, ttl, allow_new_lock)
         recover_from_script_flush do
-          @redis.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl]
+          @redis.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl, allow_new_lock]
         end
       end
 
@@ -141,23 +148,26 @@ module Redlock
       end
     end
 
-    def try_lock_instances(resource, ttl, extend)
-      @retry_count.times do
-        lock_info = lock_instances(resource, ttl, extend)
-        return lock_info if lock_info
+    def try_lock_instances(resource, ttl, options)
+      tries = options[:extend] ? 1 : @retry_count
+
+      tries.times do |attempt_number|
+        # Wait a random delay before retrying.
+        sleep((@retry_delay + rand(@retry_jitter)).to_f / 1000) if attempt_number > 0
 
-        # Wait a random delay before retrying
-        sleep(rand(@retry_delay).to_f / 1000)
+        lock_info = lock_instances(resource, ttl, options)
+        return lock_info if lock_info
       end
 
       false
     end
 
-    def lock_instances(resource, ttl, extend)
-      value = extend ? extend.fetch(:value) : SecureRandom.uuid
+    def lock_instances(resource, ttl, options)
+      value = options.fetch(:extend, { value: SecureRandom.uuid })[:value]
+      allow_new_lock = (options[:extend_life] || options[:extend_only_if_life]) ? 'no' : 'yes'
 
       locked, time_elapsed = timed do
-        @servers.select { |s| s.lock(resource, value, ttl) }.size
+        @servers.select { |s| s.lock resource, value, ttl, allow_new_lock }.size
       end
 
       validity = ttl - time_elapsed - drift(ttl)

data/lib/redlock/testing.rb

@@ -4,17 +4,17 @@ module Redlock
 
     alias_method :try_lock_instances_without_testing, :try_lock_instances
 
-    def try_lock_instances(resource, ttl, extend)
+    def try_lock_instances(resource, ttl, options)
       if @testing_mode == :bypass
         {
           validity: ttl,
           resource: resource,
-          value: extend ? extend.fetch(:value) : SecureRandom.uuid
+          value: options[:extend] ? options[:extend].fetch(:value) : SecureRandom.uuid
         }
       elsif @testing_mode == :fail
         false
       else
-        try_lock_instances_without_testing resource, ttl, extend
+        try_lock_instances_without_testing resource, ttl, options
       end
     end
 

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '0.1.5'
+  VERSION = '0.2.1'
 end

data/redlock.gemspec

@@ -18,10 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'redis', '~> 3', '>= 3.0.5'
+  spec.add_dependency 'redis', '>= 3.0.0', '< 5.0'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "coveralls", "~> 0.8.13"
+  spec.add_development_dependency 'rake', '~> 11.1', '>= 11.1.2'
+  spec.add_development_dependency 'rspec', '~> 3', '>= 3.0.0'
 end

data/spec/client_spec.rb

@@ -3,20 +3,26 @@ require 'securerandom'
 
 RSpec.describe Redlock::Client do
   # It is recommended to have at least 3 servers in production
-  let(:lock_manager) { Redlock::Client.new }
+  let(:lock_manager_opts) { { retry_count: 3 } }
+  let(:lock_manager) { Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, lock_manager_opts) }
   let(:resource_key) { SecureRandom.hex(3)  }
   let(:ttl) { 1000 }
+  let(:redis1_host) { ENV["REDIS1_HOST"] || "localhost" }
+  let(:redis1_port) { ENV["REDIS1_PORT"] || "6379" }
+  let(:redis2_host) { ENV["REDIS2_HOST"] || "127.0.0.1" }
+  let(:redis2_port) { ENV["REDIS2_PORT"] || "6379" }
 
   describe 'initialize' do
     it 'accepts both redis URLs and Redis objects' do
-      servers = [ 'redis://localhost:6379', Redis.new(url: 'redis://127.0.0.1:6379') ]
+      print redis1_host
+      servers = [ "redis://#{redis1_host}:#{redis1_port}", Redis.new(url: "redis://#{redis2_host}:#{redis2_port}") ]
       redlock = Redlock::Client.new(servers)
 
       redlock_servers = redlock.instance_variable_get(:@servers).map do |s|
-        s.instance_variable_get(:@redis).client.host
+        s.instance_variable_get(:@redis).connection[:host]
       end
 
-      expect(redlock_servers).to match_array(%w{ localhost 127.0.0.1 })
+      expect(redlock_servers).to match_array([redis1_host, redis2_host])
     end
   end
 
@@ -43,10 +49,19 @@ RSpec.describe Redlock::Client do
         expect(@lock_info[:value]).to eq(my_lock_info[:value])
       end
 
-      it "sets the given value when trying to extend a non-existent lock" do
-        @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'})
-        expect(@lock_info).to be_lock_info_for(resource_key)
-        expect(@lock_info[:value]).to eq('hello world') # really we should test what's in redis
+      context 'when extend_only_if_life flag is given' do
+        it 'does not extend a non-existent lock' do
+          @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'}, extend_only_if_life: true)
+          expect(@lock_info).to eq(false)
+        end
+      end
+
+      context 'when extend_only_if_life flag is not given' do
+        it "sets the given value when trying to extend a non-existent lock" do
+          @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'}, extend_only_if_life: false)
+          expect(@lock_info).to be_lock_info_for(resource_key)
+          expect(@lock_info[:value]).to eq('hello world') # really we should test what's in redis
+        end
       end
 
       it "doesn't extend somebody else's lock" do
@@ -71,6 +86,33 @@ RSpec.describe Redlock::Client do
         lock_info = lock_manager.lock(resource_key, ttl, extend: yet_another_lock_info)
         expect(lock_info).to eql(false)
       end
+
+      it 'retries up to \'retry_count\' times' do
+        expect(lock_manager).to receive(:lock_instances).exactly(
+          lock_manager_opts[:retry_count]).times.and_return(false)
+        lock_manager.lock(resource_key, ttl)
+      end
+
+      it 'sleeps in between retries' do
+        expect(lock_manager).to receive(:sleep).exactly(lock_manager_opts[:retry_count] - 1).times
+        lock_manager.lock(resource_key, ttl)
+      end
+
+      it 'sleeps at least the specified retry_delay in milliseconds' do
+        expected_minimum = described_class::DEFAULT_RETRY_DELAY
+        expect(lock_manager).to receive(:sleep) do |sleep|
+          expect(sleep).to satisfy { |value| value >= expected_minimum / 1000.to_f }
+        end.at_least(:once)
+        lock_manager.lock(resource_key, ttl)
+      end
+
+      it 'sleeps a maximum of retry_delay + retry_jitter in milliseconds' do
+        expected_maximum = described_class::DEFAULT_RETRY_DELAY + described_class::DEFAULT_RETRY_JITTER
+        expect(lock_manager).to receive(:sleep) do |sleep|
+          expect(sleep).to satisfy { |value| value < expected_maximum / 1000.to_f }
+        end.at_least(:once)
+        lock_manager.lock(resource_key, ttl)
+      end
     end
 
     context 'when script cache has been flushed' do
@@ -192,6 +234,11 @@ RSpec.describe Redlock::Client do
         lock_manager.lock!(resource_key, ttl) { fail } rescue nil
         expect(resource_key).to be_lockable(lock_manager, ttl)
       end
+
+      it 'passes the extension parameter' do
+        my_lock_info = lock_manager.lock(resource_key, ttl)
+        expect{ lock_manager.lock!(resource_key, ttl, extend: my_lock_info){} }.to_not raise_error
+      end
     end
 
     context 'when lock is not available' do

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ require 'coveralls'
 Coveralls.wear!
 require 'redlock'
 
-LOCK_INFO_KEYS = %i{validity resource value}
+LOCK_INFO_KEYS = [:validity, :resource, :value]
 
 RSpec::Matchers.define :be_lock_info_for do |resource|
   def correct_type?(actual)

metadata

@@ -1,91 +1,89 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.1
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-01 00:00:00.000000000 Z
+date: 2017-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
-    - - ! '>='
+        version: 3.0.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
-    - - ! '>='
+        version: 3.0.0
+    - - "<"
       - !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.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.13
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.13
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 11.1.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 11.1.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 3.0.0
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
 email:
 - leandro.ribeiro.moreira@gmail.com
@@ -93,15 +91,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CONTRIBUTORS
 - Gemfile
 - Gemfile.lock
 - LICENSE
+- Makefile
 - README.md
 - Rakefile
+- clean_docker.sh
+- docker-compose.yml
 - lib/redlock.rb
 - lib/redlock/client.rb
 - lib/redlock/testing.rb
@@ -120,17 +121,17 @@ 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.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.