redlock 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d883de4dd36be4eab1fd32417cdc59a99cd4a7e0a68efbbe1a3865a8f9150ea7
-  data.tar.gz: f732c4b1fb41bb2d9b34917879d6bc893375d9a2d4d527ecfe29d935c3d998a2
+  metadata.gz: f27e3a9be9009072c86f2f38a18bdfdcd2f177890aac365d981711dc040acd2e
+  data.tar.gz: efedd1080833cdee147afe6427878ad0df7c824e981e4e8a48c563ac68350d05
 SHA512:
-  metadata.gz: b05d03ae1e3e6de8b21d9cc2d7c367d03dba26a1b72b06e821a07e81183345a9ea4e32a5a984d941eb6ef5cd628acb446946e9395d37c7e532b16b5e6444b1eb
-  data.tar.gz: 3066e7c68d4dd14e7e193bb58f29aad00a4624a47aabd4b7b1dfff32318bcaffad7f38910e1b2ab77a0e8572a71f828dc4c83d8af8a3cd13fe95da7e95910a6e
+  metadata.gz: aed115da4ab51ae932533d73e2f2f79d7722e6d77471028bb685d89149d6085fd395af368e9a143231b25b680a57c1ad4d236365396974c12416dac1131cabd8
+  data.tar.gz: 75b69cd60c2f562b087179dc939c2fb2bbf3514018dd8c302cf4bc2c4cfa4352a1310dd7cfc35042badcd8c86fc5d237d3a6bcafc57385ca2afcc5a2a280c7bf

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    redlock (1.1.0)
+    redlock (1.2.0)
       redis (>= 3.0.0, < 5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    connection_pool (2.2.2)
     coveralls (0.8.22)
       json (>= 1.8, < 3)
       simplecov (~> 0.16.1)
@@ -16,7 +17,7 @@ GEM
     diff-lcs (1.3)
     docile (1.3.1)
     json (2.1.0)
-    rake (11.3.0)
+    rake (13.0.1)
     redis (4.1.1)
     rspec (3.5.0)
       rspec-core (~> 3.5.0)
@@ -45,8 +46,9 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  connection_pool (~> 2.2)
   coveralls (~> 0.8)
-  rake (~> 11.1, >= 11.1.2)
+  rake (~> 13.0, >= 11.1.2)
   redlock!
   rspec (~> 3, >= 3.0.0)
 

data/README.md

@@ -1,11 +1,9 @@
-[![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)
 [![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)
 [![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.
@@ -139,6 +137,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/lib/redlock.rb

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

data/lib/redlock/client.rb

@@ -93,11 +93,11 @@ 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
@@ -122,11 +122,22 @@ module Redlock
         end
       eos
 
+      module ConnectionPoolLike
+        def with
+          yield self
+        end
+      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 = Redis.new(connection)
+          end
+          @redis.extend(ConnectionPoolLike)
         end
 
         load_scripts
@@ -134,7 +145,7 @@ module Redlock
 
       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.with { |conn| conn.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl, allow_new_lock] }
         end
       rescue Redis::BaseConnectionError
         false
@@ -142,7 +153,7 @@ module Redlock
 
       def unlock(resource, val)
         recover_from_script_flush do
-          @redis.evalsha @unlock_script_sha, keys: [resource], argv: [val]
+          @redis.with { |conn| conn.evalsha @unlock_script_sha, keys: [resource], argv: [val] }
         end
       rescue
         # Nothing to do, unlocking is just a best-effort attempt.
@@ -151,8 +162,8 @@ module Redlock
       private
 
       def load_scripts
-        @unlock_script_sha = @redis.script(:load, UNLOCK_SCRIPT)
-        @lock_script_sha = @redis.script(:load, LOCK_SCRIPT)
+        @unlock_script_sha = @redis.with { |conn| conn.script(:load, UNLOCK_SCRIPT) }
+        @lock_script_sha = @redis.with { |conn| conn.script(:load, LOCK_SCRIPT) }
       end
 
       def recover_from_script_flush
@@ -179,7 +190,7 @@ module Redlock
 
       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)) if attempt_number > 0
 
         lock_info = lock_instances(resource, ttl, options)
         return lock_info if lock_info
@@ -188,6 +199,17 @@ module Redlock
       false
     end
 
+    def attempt_retry_delay(attempt_number)
+      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_only_if_locked] ? 'no' : 'yes'

data/lib/redlock/testing.rb

@@ -1,17 +1,27 @@
 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,14 +31,14 @@ 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
+        load_scripts_without_testing unless Redlock::Client.testing_mode == :bypass
       rescue Redis::CommandError
         # FakeRedis doesn't have #script, but doesn't need it either.
         raise unless defined?(::FakeRedis)

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/redlock.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'redis', '>= 3.0.0', '< 5.0'
 
   spec.add_development_dependency "coveralls", "~> 0.8"
-  spec.add_development_dependency 'rake', '~> 11.1', '>= 11.1.2'
+  spec.add_development_dependency 'rake', '>= 11.1.2', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3', '>= 3.0.0'
+  spec.add_development_dependency 'connection_pool', '~> 2.2'
 end

data/spec/client_spec.rb

@@ -1,6 +1,7 @@
 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
@@ -25,6 +26,15 @@ RSpec.describe Redlock::Client do
 
       expect(redlock_servers).to match_array([redis1_host, redis2_host])
     end
+
+    it 'accepts ConnectionPool objects' do
+      pool = ConnectionPool.new { Redis.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
   end
 
   describe 'lock' do
@@ -160,13 +170,29 @@ 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
     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.
         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
@@ -178,13 +204,22 @@ 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'))
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
         expect(lock_manager.lock(resource_key, ttl)).to be_falsey
-        redis_instance.instance_variable_set(:@redis, Redis.new(url: "redis://#{redis1_host}:#{redis1_port}"))
+        redis_instance.instance_variable_set(:@redis, old_redis)
         expect(lock_manager.lock(resource_key, ttl)).to be_truthy
       end
     end
 
+    def unreachable_redis
+      redis = Redis.new(url: 'redis://localhost:46864')
+      def redis.with
+        yield self
+      end
+      redis
+    end
+
     context 'when script cache has been flushed' do
       before(:each) do
         @manipulated_instance = lock_manager.instance_variable_get(:@servers).first
@@ -316,7 +351,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-15 00:00:00.000000000 Z
+date: 2020-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -48,42 +48,56 @@ dependencies:
   name: rake
   requirement: !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'
   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.0.0
     - - "~>"
       - !ruby/object:Gem::Version
         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.0.0
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
 email:
 - leandro.ribeiro.moreira@gmail.com
@@ -130,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.