redlock 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 12311731641f60b7873ced7fcb039d073fc21525
-  data.tar.gz: 58bc941bc7bbebc10b3fcc32a32e970c3abcefe8
+SHA256:
+  metadata.gz: 679d1c44fcda7a2eaa70bdfe38c30e4ee79e417bef0b3ce064aceaf0a9cc0bbb
+  data.tar.gz: 48b6a41c4cc27b8ff8878647dd494a6b87e3b17e540b75d8699e32d4ee982aa5
 SHA512:
-  metadata.gz: 719b17fb2701e48d3f574f198bafd078fd0f9b6ec91f686e4ece547e222c1b4bf09f5ee94868f1d1417c2e6c87d5c3b4742a185c13bb005fc83d868b2b5d0bc1
-  data.tar.gz: cc759db7fe3ba5f8cf09f1f1427564d1c338a97dc1959304e7fdc561f2817e5f133a54b381382ca1b96712e3109f41247ffa5da4a40bf6fd05a8bfb2d875832b
+  metadata.gz: a31815a7da2fa6f5c3af35734294cdb34fdfba19dc12eaf25abe950db65be1356afc397ff29a73823d267d99d0069f86651385c1e262da6ced7541345212abda
+  data.tar.gz: cd4e41fe60732180b4b5f3d848715954074f8a063c1513c89e73a37311d5d4c0d8fbe1bbd92b063955324929f07bf59232040de104bfeb14d18837d297910d59

data/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: Ruby CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby-version: [3.1, "3.0", "2.7", "2.6", "2.5", "ruby-head"]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Start Redis
+        uses: supercharge/redis-github-action@1.2.0
+        with:
+          redis-version: 6
+      - name: Run tests
+        run: bundle exec rspec
+

data/.gitignore

@@ -1,3 +1,5 @@
 *.gem
 coverage/
 .bundle/
+dump.rdb
+Gemfile.lock

data/Makefile

@@ -2,3 +2,8 @@ default: test
 test:
 	docker-compose run --rm test
 
+build:
+	docker-compose run --rm test gem build redlock.gemspec
+
+publish:
+	docker-compose run --rm test gem push `ls -lt *gem | head -n 1 | awk '{ print $$9 }'`

data/README.md

@@ -1,12 +1,8 @@
-[![Stories in Ready](https://badge.waffle.io/leandromoreira/redlock-rb.png?label=ready&title=Ready)](https://waffle.io/leandromoreira/redlock-rb)
-[![Build Status](https://travis-ci.org/leandromoreira/redlock-rb.svg?branch=master)](https://travis-ci.org/leandromoreira/redlock-rb)
+[![Build Status](https://github.com/leandromoreira/redlock-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/leandromoreira/redlock-rb/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/leandromoreira/redlock-rb/badge.svg?branch=master)](https://coveralls.io/r/leandromoreira/redlock-rb?branch=master)
 [![Code Climate](https://codeclimate.com/github/leandromoreira/redlock-rb/badges/gpa.svg)](https://codeclimate.com/github/leandromoreira/redlock-rb)
-[![Dependency Status](https://gemnasium.com/leandromoreira/redlock-rb.svg)](https://gemnasium.com/leandromoreira/redlock-rb)
 [![Gem Version](https://badge.fury.io/rb/redlock.svg)](http://badge.fury.io/rb/redlock)
-[![security](https://hakiri.io/github/leandromoreira/redlock-rb/master.svg)](https://hakiri.io/github/leandromoreira/redlock-rb/master)
 [![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)
 
 
 # Redlock - A ruby distributed lock using redis.
@@ -19,7 +15,7 @@ This is an implementation of a proposed [distributed lock algorithm with Redis](
 
 ## Compatibility
 
-Redlock works with Redis versions 2.6 or later.
+Redlock works with Redis versions 6.0 or later.
 
 ## Installation
 
@@ -45,6 +41,7 @@ Or install it yourself as:
 
 ### Acquiring a lock
 
+NOTE: All expiration durations are in milliseconds.
 ```ruby
   # Locking
   lock_manager = Redlock::Client.new([ "redis://127.0.0.1:7777", "redis://127.0.0.1:7778", "redis://127.0.0.1:7779" ])
@@ -108,10 +105,72 @@ rescue Redlock::LockError
 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 the `extend_life` parameter:
+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 and released by someone else in the meantime. To only extend the life of the lock if currently locked by yourself, use the `extend_only_if_locked` parameter:
 
 ```ruby
-lock_manager.lock("resource key", 3000, extend: lock_info, extend_life: true)
+lock_manager.lock("resource key", 3000, extend: lock_info, extend_only_if_locked: true)
+```
+
+### Querying lock status
+
+You can check if a resource is locked:
+
+```ruby
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+lock_manager.locked?(resource)
+#=> true
+
+lock_manager.unlock(lock_info)
+lock_manager.locked?(resource)
+#=> false
+```
+
+Any caller can call the above method to query the status. If you hold a lock and would like to check if it is valid, you can use the `valid_lock?` method:
+
+```ruby
+lock_info = lock_manager.lock("resource_key", 2000)
+lock_manager.valid_lock?(lock_info)
+#=> true
+
+lock_manager.unlock(lock_info)
+lock_manager.valid_lock?(lock_info)
+#=> false
+```
+
+The above methods **are not safe if you are using this to time critical code**, since they return true if the lock has not expired, even if there's only (for example) 1ms left on the lock. If you want to safely time the lock validity, you can use the `get_remaining_ttl_for_lock` and `get_remaining_ttl_for_resource` methods.
+
+Use `get_remaining_ttl_for_lock` if you hold a lock and want to check the TTL specifically for your lock:
+```ruby
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+sleep 1
+
+lock_manager.get_remaining_ttl_for_lock(lock_info)
+#=> 986
+
+lock_manager.unlock(lock_info)
+lock_manager.get_remaining_ttl_for_lock(lock_info)
+#=> nil
+```
+
+Use `get_remaining_ttl_for_resource` if you do not hold a lock, but want to know the remaining TTL on a locked resource:
+```ruby
+# Some part of the code
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+
+# Some other part of the code
+lock_manager.locked?(resource)
+#=> true
+lock_manager.get_remaining_ttl_for_resource(resource)
+#=> 1975
+
+# Sometime later
+lock_manager.locked?(resource)
+#=> false
+lock_manager.get_remaining_ttl_for_resource(resource)
+#=> nil
 ```
 
 ## Redis client configuration
@@ -119,7 +178,7 @@ lock_manager.lock("resource key", 3000, extend: lock_info, extend_life: true)
 `Redlock::Client` expects URLs or Redis objects on initialization. Redis objects should be used for configuring the connection in more detail, i.e. setting username and password.
 
 ```ruby
-servers = [ 'redis://localhost:6379', Redis.new(:url => 'redis://someotherhost:6379') ]
+servers = [ 'redis://localhost:6379', RedisClient.new(:url => 'redis://someotherhost:6379') ]
 redlock = Redlock::Client.new(servers)
 ```
 
@@ -139,6 +198,14 @@ It's possible to customize the retry logic providing the following options:
                  })
 ```
 
+It is possible to associate `:retry_delay` option with `Proc` object. It will be called every time, with attempt number
+as argument, to get delay time value before next retry.
+
+```ruby
+retry_delay = proc { |attempt_number| 200 * attempt_number ** 2 } # delay of 200ms for 1st retry, 800ms for 2nd retry, etc.
+lock_manager = Redlock::Client.new(servers, retry_delay: retry_delay)
+```
+
 For more information you can check [documentation](http://www.rubydoc.info/gems/redlock/Redlock%2FClient:initialize).
 
 ## Run tests

data/docker-compose.yml

@@ -11,17 +11,23 @@ services:
       - REDIS1_PORT=6379
       - REDIS2_HOST=redis2.local.com
       - REDIS2_PORT=6379
+      - REDIS3_HOST=redis3.local.com
+      - REDIS3_PORT=6379
       - DEFAULT_REDIS_HOST=redis1.local.com
       - DEFAULT_REDIS_PORT=6379
     links:
       - redis1:redis1.local.com
       - redis2:redis2.local.com
+      - redis3:redis3.local.com
     depends_on:
       - redis1
       - redis2
+      - redis3
 
   redis1:
     image: redis
   redis2:
     image: redis
+  redis3:
+    image: redis
 

data/lib/redlock/client.rb

@@ -1,7 +1,9 @@
-require 'redis'
+require 'redis-client'
 require 'securerandom'
 
 module Redlock
+  include Scripts
+
   class Client
     DEFAULT_REDIS_HOST    = ENV["DEFAULT_REDIS_HOST"] || "localhost"
     DEFAULT_REDIS_PORT    = ENV["DEFAULT_REDIS_PORT"] || "6379"
@@ -54,12 +56,25 @@ module Redlock
     # +resource+:: the resource (or key) string to be locked.
     # +ttl+:: The time-to-live in ms for the lock.
     # +options+:: Hash of optional parameters
+    #  * +retry_count+: see +initialize+
+    #  * +retry_delay+: see +initialize+
+    #  * +retry_jitter+: see +initialize+
     #  * +extend+: A lock ("lock_info") to extend.
-    #  * +extend_only_if_life+: If +extend+ is given, only acquire lock if currently held
+    #  * +extend_only_if_locked+: Boolean, if +extend+ is given, only acquire lock if currently held
+    #  * +extend_only_if_life+: Deprecated, same as +extend_only_if_locked+
+    #  * +extend_life+: Deprecated, same as +extend_only_if_locked+
     # +block+:: an optional block to be executed; after its execution, the lock (if successfully
     # acquired) is automatically unlocked.
     def lock(resource, ttl, options = {}, &block)
       lock_info = try_lock_instances(resource, ttl, options)
+      if options[:extend_only_if_life] && !Gem::Deprecate.skip
+        warn 'DEPRECATION WARNING: The `extend_only_if_life` option has been renamed `extend_only_if_locked`.'
+        options[:extend_only_if_locked] = options[:extend_only_if_life]
+      end
+      if options[:extend_life] && !Gem::Deprecate.skip
+        warn 'DEPRECATION WARNING: The `extend_life` option has been renamed `extend_only_if_locked`.'
+        options[:extend_only_if_locked] = options[:extend_life]
+      end
 
       if block_given?
         begin
@@ -83,73 +98,117 @@ 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)
+    def lock!(resource, *args)
       fail 'No block passed' unless block_given?
 
-      lock(*args) do |lock_info|
-        raise LockError, 'failed to acquire lock' unless lock_info
+      lock(resource, *args) do |lock_info|
+        raise LockError, resource unless lock_info
         return yield
       end
     end
 
+    # Gets remaining ttl of a resource. The ttl is returned if the holder
+    # currently holds the lock and it has not expired, otherwise the method
+    # returns nil.
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def get_remaining_ttl_for_lock(lock_info)
+      ttl_info = try_get_remaining_ttl(lock_info[:resource])
+      return nil if ttl_info.nil? || ttl_info[:value] != lock_info[:value]
+      ttl_info[:ttl]
+    end
+
+    # Gets remaining ttl of a resource. If there is no valid lock, the method
+    # returns nil.
+    # Params:
+    # +resource+:: the name of the resource (string) for which to check the ttl
+    def get_remaining_ttl_for_resource(resource)
+      ttl_info = try_get_remaining_ttl(resource)
+      return nil if ttl_info.nil?
+      ttl_info[:ttl]
+    end
+
+    # Checks if a resource is locked
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def locked?(resource)
+      ttl = get_remaining_ttl_for_resource(resource)
+      !(ttl.nil? || ttl.zero?)
+    end
+
+    # Checks if a lock is still valid
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def valid_lock?(lock_info)
+      ttl = get_remaining_ttl_for_lock(lock_info)
+      !(ttl.nil? || ttl.zero?)
+    end
+
     private
 
     class RedisInstance
-      UNLOCK_SCRIPT = <<-eos
-        if redis.call("get",KEYS[1]) == ARGV[1] then
-          return redis.call("del",KEYS[1])
-        else
-          return 0
+      module ConnectionPoolLike
+        def with
+          yield self
         end
-      eos
-
-      # thanks to https://github.com/sbertrang/redis-distlock/blob/master/lib/Redis/DistLock.pm
-      # 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 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
+      end
 
       def initialize(connection)
-        if connection.respond_to?(:client)
+        if connection.respond_to?(:with)
           @redis = connection
         else
-          @redis = Redis.new(connection)
+          if connection.respond_to?(:client)
+            @redis = connection
+          else
+            @redis = RedisClient.new(connection)
+          end
+          @redis.extend(ConnectionPoolLike)
         end
-
-        load_scripts
       end
 
       def lock(resource, val, ttl, allow_new_lock)
         recover_from_script_flush do
-          @redis.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl, allow_new_lock]
+          @redis.call('EVALSHA', Scripts::LOCK_SCRIPT_SHA, 1, resource, val, ttl, allow_new_lock)
         end
-      rescue Redis::CannotConnectError
-        false
       end
 
       def unlock(resource, val)
         recover_from_script_flush do
-          @redis.evalsha @unlock_script_sha, keys: [resource], argv: [val]
+          @redis.call('EVALSHA', Scripts::UNLOCK_SCRIPT_SHA, 1, resource, val)
         end
       rescue
         # Nothing to do, unlocking is just a best-effort attempt.
       end
 
+      def get_remaining_ttl(resource)
+        recover_from_script_flush do
+          @redis.call('EVALSHA', Scripts::PTTL_SCRIPT_SHA, 1, resource)
+        end
+      rescue RedisClient::ConnectionError
+        nil
+      end
+
       private
 
       def load_scripts
-        @unlock_script_sha = @redis.script(:load, UNLOCK_SCRIPT)
-        @lock_script_sha = @redis.script(:load, LOCK_SCRIPT)
+        scripts = [
+          Scripts::UNLOCK_SCRIPT,
+          Scripts::LOCK_SCRIPT,
+          Scripts::PTTL_SCRIPT
+        ]
+
+        @redis.with do |connnection|
+          scripts.each do |script|
+            connnection.call('SCRIPT', 'LOAD', script)
+          end
+        end
       end
 
       def recover_from_script_flush
         retry_on_noscript = true
         begin
           yield
-        rescue Redis::CommandError => e
+        rescue RedisClient::CommandError => e
           # When somebody has flushed the Redis instance's script cache, we might
           # want to reload our scripts. Only attempt this once, though, to avoid
           # going into an infinite loop.
@@ -165,11 +224,12 @@ module Redlock
     end
 
     def try_lock_instances(resource, ttl, options)
-      tries = options[:extend] ? 1 : (@retry_count + 1)
+      retry_count = options[:retry_count] || @retry_count
+      tries = options[:extend] ? 1 : (retry_count + 1)
 
       tries.times do |attempt_number|
         # Wait a random delay before retrying.
-        sleep((@retry_delay + rand(@retry_jitter)).to_f / 1000) if attempt_number > 0
+        sleep(attempt_retry_delay(attempt_number, options)) if attempt_number > 0
 
         lock_info = lock_instances(resource, ttl, options)
         return lock_info if lock_info
@@ -178,9 +238,23 @@ module Redlock
       false
     end
 
+    def attempt_retry_delay(attempt_number, options)
+      retry_delay = options[:retry_delay] || @retry_delay
+      retry_jitter = options[:retry_jitter] || @retry_jitter
+
+      retry_delay =
+        if retry_delay.respond_to?(:call)
+          retry_delay.call(attempt_number)
+        else
+          retry_delay
+        end
+
+      (retry_delay + rand(retry_jitter)).to_f / 1000
+    end
+
     def lock_instances(resource, ttl, options)
       value = (options[:extend] || { value: SecureRandom.uuid })[:value]
-      allow_new_lock = (options[:extend_life] || options[:extend_only_if_life]) ? 'no' : 'yes'
+      allow_new_lock = options[:extend_only_if_locked] ? 'no' : 'yes'
 
       locked, time_elapsed = timed do
         @servers.select { |s| s.lock resource, value, ttl, allow_new_lock }.size
@@ -196,6 +270,37 @@ module Redlock
       end
     end
 
+    def try_get_remaining_ttl(resource)
+      # Responses from the servers are a 2 tuple of format [lock_value, ttl].
+      # The lock_value is nil if it does not exist. Since servers may have
+      # different lock values, the responses are grouped by the lock_value and
+      # transofrmed into a hash: { lock_value1 => [ttl1, ttl2, ttl3],
+      # lock_value2 => [ttl4, tt5] }
+      ttls_by_value, time_elapsed = timed do
+        @servers.map { |s| s.get_remaining_ttl(resource) }
+          .select { |ttl_tuple| ttl_tuple&.first }
+          .group_by(&:first)
+          .transform_values { |ttl_tuples| ttl_tuples.map { |t| t.last } }
+      end
+
+      # Authoritative lock value is that which is returned by the majority of
+      # servers
+      authoritative_value, ttls =
+        ttls_by_value.max_by { |(lock_value, ttls)| ttls.length }
+
+      if ttls && ttls.size >= @quorum
+        # Return the  minimum TTL of an N/2+1 selection. It will always be
+        # correct (it will guarantee that at least N/2+1 servers have a TTL that
+        # value or longer)
+        min_ttl = ttls.sort.last(@quorum).first
+        min_ttl = min_ttl - time_elapsed - drift(min_ttl)
+        { value: authoritative_value, ttl: min_ttl }
+      else
+        # No lock_value is authoritatively held for the resource
+        nil
+      end
+    end
+
     def drift(ttl)
       # Add 2 milliseconds to the drift to account for Redis expires
       # precision, which is 1 millisecond, plus 1 millisecond min drift

data/lib/redlock/scripts.rb

@@ -0,0 +1,34 @@
+require 'digest'
+
+module Redlock
+  module Scripts
+    UNLOCK_SCRIPT = <<-eos
+      if redis.call("get",KEYS[1]) == ARGV[1] then
+        return redis.call("del",KEYS[1])
+      else
+        return 0
+      end
+    eos
+
+    # thanks to https://github.com/sbertrang/redis-distlock/blob/master/lib/Redis/DistLock.pm
+    # 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 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
+
+    PTTL_SCRIPT = <<-eos
+      return { redis.call("get", KEYS[1]), redis.call("pttl", KEYS[1]) }
+    eos
+
+    # We do not want to load the scripts on every Redlock::Client initialization.
+    # Hence, we rely on Redis handing out SHA1 hashes of the cached scripts and
+    # pre-calculate them instead of loading the scripts unconditionally. If the scripts
+    # have not been cached on Redis, `recover_from_script_flush` has our backs.
+    UNLOCK_SCRIPT_SHA = Digest::SHA1.hexdigest(UNLOCK_SCRIPT)
+    LOCK_SCRIPT_SHA   = Digest::SHA1.hexdigest(LOCK_SCRIPT)
+    PTTL_SCRIPT_SHA   = Digest::SHA1.hexdigest(PTTL_SCRIPT)
+  end
+end

data/lib/redlock/testing.rb

@@ -1,17 +1,29 @@
+require 'redlock'
+
 module Redlock
   class Client
-    attr_writer :testing_mode
+    class << self
+      attr_accessor :testing_mode
+    end
+
+    def testing_mode=(mode)
+      warn 'DEPRECATION WARNING: Instance-level `testing_mode` has been removed, and this ' +
+        'setter will be removed in the future. Please set the testing mode on the `Redlock::Client` ' +
+        'instead, e.g. `Redlock::Client.testing_mode = :bypass`.'
+
+      self.class.testing_mode = mode
+    end
 
     alias_method :try_lock_instances_without_testing, :try_lock_instances
 
     def try_lock_instances(resource, ttl, options)
-      if @testing_mode == :bypass
+      if self.class.testing_mode == :bypass
         {
           validity: ttl,
           resource: resource,
           value: options[:extend] ? options[:extend].fetch(:value) : SecureRandom.uuid
         }
-      elsif @testing_mode == :fail
+      elsif self.class.testing_mode == :fail
         false
       else
         try_lock_instances_without_testing resource, ttl, options
@@ -21,15 +33,15 @@ module Redlock
     alias_method :unlock_without_testing, :unlock
 
     def unlock(lock_info)
-      unlock_without_testing lock_info unless @testing_mode == :bypass
+      unlock_without_testing lock_info unless self.class.testing_mode == :bypass
     end
 
     class RedisInstance
       alias_method :load_scripts_without_testing, :load_scripts
 
       def load_scripts
-        load_scripts_without_testing
-      rescue Redis::CommandError
+        load_scripts_without_testing unless Redlock::Client.testing_mode == :bypass
+      rescue RedisClient::CommandError
         # FakeRedis doesn't have #script, but doesn't need it either.
         raise unless defined?(::FakeRedis)
       rescue NoMethodError

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/redlock.rb

@@ -2,6 +2,11 @@ require 'redlock/version'
 
 module Redlock
   autoload :Client, 'redlock/client'
+  autoload :Scripts, 'redlock/scripts'
 
-  LockError = Class.new(StandardError)
+  class LockError < StandardError
+    def initialize(resource)
+      super "failed to acquire lock on '#{resource}'".freeze
+    end
+  end
 end

data/redlock.gemspec

@@ -1,26 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'redlock/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "redlock"
+  spec.name          = 'redlock'
   spec.version       = Redlock::VERSION
-  spec.authors       = ["Leandro Moreira"]
-  spec.email         = ["leandro.ribeiro.moreira@gmail.com"]
-  spec.summary       = %q{Distributed lock using Redis written in Ruby.}
-  spec.description   = %q{Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.}
-  spec.homepage      = "https://github.com/leandromoreira/redlock-rb"
+  spec.authors       = ['Leandro Moreira']
+  spec.email         = ['leandro.ribeiro.moreira@gmail.com']
+  spec.summary       = 'Distributed lock using Redis written in Ruby.'
+  spec.description   = 'Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.'
+  spec.homepage      = 'https://github.com/leandromoreira/redlock-rb'
   spec.license       = 'BSD-2-Clause'
 
   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.require_paths = ['lib']
 
-  spec.add_dependency 'redis', '>= 3.0.0', '< 5.0'
+  spec.add_dependency 'redis-client'
 
-  spec.add_development_dependency "coveralls", "~> 0.8"
-  spec.add_development_dependency 'rake', '~> 11.1', '>= 11.1.2'
+  spec.add_development_dependency 'connection_pool', '~> 2.2'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'json', '>= 2.3.0', '~> 2.3.1'
+  spec.add_development_dependency 'rake', '>= 11.1.2', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3', '>= 3.0.0'
 end

data/spec/client_spec.rb

@@ -1,30 +1,60 @@
 require 'spec_helper'
 require 'securerandom'
-require 'redis'
+require 'connection_pool'
 
 RSpec.describe Redlock::Client do
   # It is recommended to have at least 3 servers in production
   let(:lock_manager_opts) { { retry_count: 3 } }
   let(:lock_manager) { Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, lock_manager_opts) }
-  let(:redis_client) { Redis.new }
+  let(:redis_client) { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
   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" }
+  let(:redis3_host) { ENV["REDIS3_HOST"] || "127.0.0.1" }
+  let(:redis3_port) { ENV["REDIS3_PORT"] || "6379" }
+  let(:unreachable_redis) {
+    redis = RedisClient.new(url: 'redis://localhost:46864')
+    def redis.with
+      yield self
+    end
+    redis
+  }
 
   describe 'initialize' do
     it 'accepts both redis URLs and Redis objects' do
-      servers = [ "redis://#{redis1_host}:#{redis1_port}", Redis.new(url: "redis://#{redis2_host}:#{redis2_port}") ]
+      servers = [ "redis://#{redis1_host}:#{redis1_port}", RedisClient.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).connection[:host]
+        s.instance_variable_get(:@redis).config.host
       end
 
       expect(redlock_servers).to match_array([redis1_host, redis2_host])
     end
+
+    it 'accepts ConnectionPool objects' do
+      pool = ConnectionPool.new { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
+      redlock = Redlock::Client.new([pool])
+
+      lock_info = lock_manager.lock(resource_key, ttl)
+      expect(resource_key).to_not be_lockable(lock_manager, ttl)
+      lock_manager.unlock(lock_info)
+    end
+
+    it 'does not load scripts' do
+      redis_client.call('SCRIPT', 'FLUSH')
+
+      pool = ConnectionPool.new { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
+      redlock = Redlock::Client.new([pool])
+
+      raw_info = redis_client.call('INFO')
+      number_of_cached_scripts = raw_info[/number_of_cached_scripts\:\d+/].split(':').last
+
+      expect(number_of_cached_scripts).to eq("0")
+    end
   end
 
   describe 'lock' do
@@ -46,7 +76,7 @@ RSpec.describe Redlock::Client do
       it 'interprets lock time as milliseconds' do
         ttl = 20000
         @lock_info = lock_manager.lock(resource_key, ttl)
-        expect(redis_client.pttl(resource_key)).to be_within(200).of(ttl)
+        expect(redis_client.call('PTTL', resource_key)).to be_within(200).of(ttl)
       end
 
       it 'can extend its own lock' do
@@ -64,9 +94,9 @@ RSpec.describe Redlock::Client do
         end
       end
 
-      context 'when extend_only_if_life flag is given' do
+      context 'when extend_only_if_locked 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)
+          @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'}, extend_only_if_locked: true)
           expect(@lock_info).to eq(false)
         end
       end
@@ -76,14 +106,14 @@ RSpec.describe Redlock::Client do
         lock_info = lock_manager.lock(resource_key, ttl)
         expect(resource_key).to_not be_lockable(lock_manager, ttl)
 
-        lock_info = lock_manager.lock(resource_key, ttl, extend: lock_info, extend_life: true)
+        lock_info = lock_manager.lock(resource_key, ttl, extend: lock_info, extend_only_if_locked: true)
         expect(lock_info).not_to be_nil
-        expect(redis_client.pttl(resource_key)).to be_within(200).of(ttl)
+        expect(redis_client.call('PTTL', resource_key)).to be_within(200).of(ttl)
       end
 
-      context 'when extend_only_if_life flag is not given' do
+      context 'when extend_only_if_locked 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)
+          @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'}, extend_only_if_locked: 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
@@ -94,6 +124,28 @@ RSpec.describe Redlock::Client do
         second_attempt = lock_manager.lock(resource_key, ttl)
         expect(second_attempt).to eq(false)
       end
+
+      context 'when extend_life flag is given' do
+        it 'treats it as extend_only_if_locked but warns it is deprecated' do
+          ttl = 20_000
+          lock_info = lock_manager.lock(resource_key, ttl)
+          expect(resource_key).to_not be_lockable(lock_manager, ttl)
+          expect(lock_manager).to receive(:warn).with(/DEPRECATION WARNING: The `extend_life`/)
+          lock_info = lock_manager.lock(resource_key, ttl, extend: lock_info, extend_life: true)
+          expect(lock_info).not_to be_nil
+        end
+      end
+
+      context 'when extend_only_if_life flag is given' do
+        it 'treats it as extend_only_if_locked but warns it is deprecated' do
+          ttl = 20_000
+          lock_info = lock_manager.lock(resource_key, ttl)
+          expect(resource_key).to_not be_lockable(lock_manager, ttl)
+          expect(lock_manager).to receive(:warn).with(/DEPRECATION WARNING: The `extend_only_if_life`/)
+          lock_info = lock_manager.lock(resource_key, ttl, extend: lock_info, extend_only_if_life: true)
+          expect(lock_info).not_to be_nil
+        end
+      end
     end
 
     context 'when lock is not available' do
@@ -138,17 +190,68 @@ RSpec.describe Redlock::Client do
         end.at_least(:once)
         lock_manager.lock(resource_key, ttl)
       end
+
+      it 'accepts retry_delay as proc' do
+        retry_delay = proc do |attempt_number|
+          expect(attempt_number).to eq(1)
+          2000
+        end
+
+        lock_manager = Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, retry_count: 1, retry_delay: retry_delay)
+        another_lock_info = lock_manager.lock(resource_key, ttl)
+
+        expect(lock_manager).to receive(:sleep) do |sleep|
+          expect(sleep * 1000).to be_within(described_class::DEFAULT_RETRY_JITTER).of(2000)
+        end.exactly(:once)
+        lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(another_lock_info)
+      end
+
+      context 'when retry_count is given' do
+        it 'prioritizes the retry_count in option and tries up to \'retry_count\' + 1 times' do
+          retry_count = 1
+          expect(retry_count).not_to eq(lock_manager_opts[:retry_count])
+          expect(lock_manager).to receive(:lock_instances).exactly(retry_count + 1).times.and_return(false)
+          lock_manager.lock(resource_key, ttl, retry_count: retry_count)
+        end
+      end
+
+      context 'when retry_delay is given' do
+        it 'prioritizes the retry_delay in option and sleeps at least the specified retry_delay in milliseconds' do
+          retry_delay = 300
+          expect(retry_delay > described_class::DEFAULT_RETRY_DELAY).to eq(true)
+          expected_minimum = 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, retry_delay: retry_delay)
+        end
+      end
+
+      context 'when retry_jitter is given' do
+        it 'prioritizes the retry_jitter in option and sleeps a maximum of retry_delay + retry_jitter in milliseconds' do
+          retry_jitter = 60
+          expect(retry_jitter > described_class::DEFAULT_RETRY_JITTER).to eq(true)
+
+          expected_maximum = described_class::DEFAULT_RETRY_DELAY + 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, retry_jitter: retry_jitter)
+        end
+      end
     end
 
     context 'when a server goes away' do
-      it 'does not raise an error on connection issues' do
-        # We re-route the lock manager to a (hopefully) non-existent Redis URL.
+      it 'raises an error on connection issues' do
+        # Set lock manager to a (hopefully) non-existent Redis URL to test error
         redis_instance = lock_manager.instance_variable_get(:@servers).first
-        redis_instance.instance_variable_set(:@redis, Redis.new(url: 'redis://localhost:46864'))
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
 
         expect {
-          expect(lock_manager.lock(resource_key, ttl)).to be_falsey
-        }.to_not raise_error
+          lock_manager.lock(resource_key, ttl)
+        }.to raise_error(RedisClient::CannotConnectError)
       end
     end
 
@@ -156,9 +259,12 @@ RSpec.describe Redlock::Client do
       it 'recovers from connection issues' do
         # Same as above.
         redis_instance = lock_manager.instance_variable_get(:@servers).first
-        redis_instance.instance_variable_set(:@redis, Redis.new(url: 'redis://localhost:46864'))
-        expect(lock_manager.lock(resource_key, ttl)).to be_falsey
-        redis_instance.instance_variable_set(:@redis, Redis.new(url: "redis://#{redis1_host}:#{redis1_port}"))
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
+        expect {
+          lock_manager.lock(resource_key, ttl)
+        }.to raise_error(RedisClient::CannotConnectError)
+        redis_instance.instance_variable_set(:@redis, old_redis)
         expect(lock_manager.lock(resource_key, ttl)).to be_truthy
       end
     end
@@ -166,10 +272,10 @@ RSpec.describe Redlock::Client do
     context 'when script cache has been flushed' do
       before(:each) do
         @manipulated_instance = lock_manager.instance_variable_get(:@servers).first
-        @manipulated_instance.instance_variable_get(:@redis).script(:flush)
+        @manipulated_instance.instance_variable_get(:@redis).call('SCRIPT', 'FLUSH')
       end
 
-      it 'does not raise a Redis::CommandError: NOSCRIPT error' do
+      it 'does not raise a RedisClient::CommandError: NOSCRIPT error' do
         expect {
           lock_manager.lock(resource_key, ttl)
         }.to_not raise_error
@@ -294,7 +400,9 @@ RSpec.describe Redlock::Client do
       after { lock_manager.unlock(@another_lock_info) }
 
       it 'raises a LockError' do
-        expect { lock_manager.lock!(resource_key, ttl) {} }.to raise_error(Redlock::LockError)
+        expect { lock_manager.lock!(resource_key, ttl) {} }.to raise_error(
+          Redlock::LockError, "failed to acquire lock on '#{resource_key}'"
+        )
       end
 
       it 'does not execute the block' do
@@ -308,6 +416,154 @@ RSpec.describe Redlock::Client do
     end
   end
 
+  describe 'get_remaining_ttl_for_resource' do
+    context 'when lock is valid' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'gets the remaining ttl of a lock' do
+        ttl = 20_000
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+        expect(remaining_ttl).to be_within(300).of(ttl)
+      end
+
+      context 'when servers respond with varying ttls' do
+        let (:servers) {
+          [
+            "redis://#{redis1_host}:#{redis1_port}",
+            "redis://#{redis2_host}:#{redis2_port}",
+            "redis://#{redis3_host}:#{redis3_port}"
+          ]
+        }
+        let (:redlock) { Redlock::Client.new(servers) }
+        after(:each) { redlock.unlock(@lock_info) if @lock_info }
+
+        it 'returns the minimum ttl value' do
+          ttl = 20_000
+          @lock_info = redlock.lock(resource_key, ttl)
+
+          # Mock redis server responses to return different ttls
+          returned_ttls = [20_000, 15_000, 10_000]
+          redlock.instance_variable_get(:@servers).each_with_index do |server, index|
+            allow(server).to(receive(:get_remaining_ttl))
+              .with(resource_key)
+              .and_return([@lock_info[:value], returned_ttls[index]])
+          end
+
+          remaining_ttl = redlock.get_remaining_ttl_for_lock(@lock_info)
+
+          # Assert that the TTL is closest to the closest to the correct value
+          expect(remaining_ttl).to be_within(300).of(returned_ttls[1])
+        end
+      end
+    end
+
+    context 'when lock is not valid' do
+      it 'returns nil' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+        expect(remaining_ttl).to be_nil
+      end
+    end
+
+    context 'when server goes away' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'does not raise an error on connection issues' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+
+        # Replace redis with unreachable instance
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
+
+        expect {
+          remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+          expect(remaining_ttl).to be_nil
+        }.to_not raise_error
+      end
+    end
+
+    context 'when a server comes back' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'recovers from connection issues' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+
+        # Replace redis with unreachable instance
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
+
+        expect(lock_manager.get_remaining_ttl_for_resource(resource_key)).to be_nil
+
+        # Restore redis
+        redis_instance.instance_variable_set(:@redis, old_redis)
+        expect(lock_manager.get_remaining_ttl_for_resource(resource_key)).to be_truthy
+      end
+    end
+  end
+
+  describe 'get_remaining_ttl_for_lock' do
+    context 'when lock is valid' do
+      it 'gets the remaining ttl of a lock' do
+        ttl = 20_000
+        lock_info = lock_manager.lock(resource_key, ttl)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_lock(lock_info)
+        expect(remaining_ttl).to be_within(300).of(ttl)
+        lock_manager.unlock(lock_info)
+      end
+    end
+
+    context 'when lock is not valid' do
+      it 'returns nil' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_lock(lock_info)
+        expect(remaining_ttl).to be_nil
+      end
+    end
+  end
+
+  describe 'locked?' do
+    context 'when lock is available' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'returns true' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        expect(lock_manager).to be_locked(resource_key)
+      end
+    end
+
+    context 'when lock is not available' do
+      it 'returns false' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        expect(lock_manager).not_to be_locked(resource_key)
+      end
+    end
+  end
+
+  describe 'valid_lock?' do
+    context 'when lock is available' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'returns true' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        expect(lock_manager).to be_valid_lock(@lock_info)
+      end
+    end
+
+    context 'when lock is not available' do
+      it 'returns false' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        expect(lock_manager).not_to be_valid_lock(lock_info)
+      end
+    end
+  end
+
   describe '#default_time_source' do
     context 'when CLOCK_MONOTONIC is available (MRI, JRuby)' do
       it 'returns a callable using Process.clock_gettime()' do

metadata

@@ -1,35 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-11 00:00:00.000000000 Z
+date: 2023-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -45,45 +53,65 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.8'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: 2.3.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 11.1.2
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '11.1'
     - - ">="
       - !ruby/object:Gem::Version
         version: 11.1.2
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
 email:
 - leandro.ribeiro.moreira@gmail.com
@@ -91,12 +119,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CONTRIBUTORS
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - Makefile
 - README.md
@@ -105,6 +132,7 @@ files:
 - docker-compose.yml
 - lib/redlock.rb
 - lib/redlock/client.rb
+- lib/redlock/scripts.rb
 - lib/redlock/testing.rb
 - lib/redlock/version.rb
 - redlock.gemspec
@@ -130,8 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.

data/.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-services:
-    - redis-server
-rvm:
-  - "2.2.2"
-script: bundle exec rspec spec
-sudo: false
-cache: bundler

data/Gemfile.lock

@@ -1,54 +0,0 @@
-PATH
-  remote: .
-  specs:
-    redlock (1.0.0)
-      redis (>= 3.0.0, < 5.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    coveralls (0.8.22)
-      json (>= 1.8, < 3)
-      simplecov (~> 0.16.1)
-      term-ansicolor (~> 1.3)
-      thor (~> 0.19.4)
-      tins (~> 1.6)
-    diff-lcs (1.3)
-    docile (1.3.1)
-    json (2.1.0)
-    rake (11.3.0)
-    redis (4.0.3)
-    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.5.0)
-    rspec-mocks (3.5.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
-    simplecov (0.16.1)
-      docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    term-ansicolor (1.6.0)
-      tins (~> 1.0)
-    thor (0.19.4)
-    tins (1.16.3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  coveralls (~> 0.8)
-  rake (~> 11.1, >= 11.1.2)
-  redlock!
-  rspec (~> 3, >= 3.0.0)
-
-BUNDLED WITH
-   1.17.2