redlock 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a91b03cbb845e7b01556262e80e946e2d72980beeebce12d51380d7c57c57fb9
-  data.tar.gz: 73d38bac32a8003a556d3d8967155d15a8edbe988fc43387174ec506b21e8c99
+  metadata.gz: 1870dc8b8577a8e8545fd952fd6c2f1ff3ac1f336bff5f632b3b89eb92eb0069
+  data.tar.gz: b5153369a5cd331a4bbc0884efd657692da4b824e0cbe0dd8ed78fdd407d7047
 SHA512:
-  metadata.gz: e55aa47e007175e619e22ec2b2ca996add245143290750c79a27fbafc8bb6bd32e5c02b07d9a9752c1ad8cb7f22a10a2b245c9b963c1b4f186427d6c7a987d3a
-  data.tar.gz: dd61e0d187a5972ecbe09bde3345c1a6174263f06fca6b7d1da3ce8be19fe5bb69ffca4cfc24073705c5b5a40551bb1a65ffba1358c5fbaf37f10ea46a15a929
+  metadata.gz: 747aa1155827f513a0612e6610dd754143c3fb65c50aaeca87506830d91c83ec40a89f7fcfb81d22395ea2cc16048cc99136894f0b6a8adb7455d2adae60c244
+  data.tar.gz: b033303f287bdbeca822c6b3f0ad829531c5740ad0716f6a6cdeb75370ea9e3874838b761f65ac242b07a07af0b1c0ab955e288059f0953aed3aeb686773a6cc

data/.gitignore

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

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    redlock (1.2.2)
+      redis (>= 3.0.0, < 5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    connection_pool (2.2.5)
+    coveralls (0.8.23)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.16.1)
+      term-ansicolor (~> 1.3)
+      thor (>= 0.19.4, < 2.0)
+      tins (~> 1.6)
+    diff-lcs (1.4.4)
+    docile (1.4.0)
+    json (2.3.1)
+    rake (13.0.6)
+    redis (4.4.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    sync (0.5.0)
+    term-ansicolor (1.7.1)
+      tins (~> 1.0)
+    thor (1.1.0)
+    tins (1.29.1)
+      sync
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  connection_pool (~> 2.2)
+  coveralls (~> 0.8)
+  json (~> 2.3.1, >= 2.3.0)
+  rake (~> 13.0, >= 11.1.2)
+  redlock!
+  rspec (~> 3, >= 3.0.0)
+
+BUNDLED WITH
+   2.2.22

data/Makefile

@@ -7,3 +7,6 @@ build:
 
 publish:
 	docker-compose run --rm test gem push `ls -lt *gem | head -n 1 | awk '{ print $$9 }'`
+
+updateLock:
+	docker-compose run --rm test bundle lock --update

data/lib/redlock/client.rb

@@ -2,6 +2,8 @@ require 'redis'
 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,6 +56,9 @@ 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_locked+: Boolean, if +extend+ is given, only acquire lock if currently held
     #  * +extend_only_if_life+: Deprecated, same as +extend_only_if_locked+
@@ -142,27 +147,6 @@ module Redlock
     private
 
     class RedisInstance
-      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
-
       module ConnectionPoolLike
         def with
           yield self
@@ -180,13 +164,11 @@ module Redlock
           end
           @redis.extend(ConnectionPoolLike)
         end
-
-        load_scripts
       end
 
       def lock(resource, val, ttl, allow_new_lock)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl, allow_new_lock] }
+          @redis.with { |conn| conn.evalsha Scripts::LOCK_SCRIPT_SHA, keys: [resource], argv: [val, ttl, allow_new_lock] }
         end
       rescue Redis::BaseConnectionError
         false
@@ -194,7 +176,7 @@ module Redlock
 
       def unlock(resource, val)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha @unlock_script_sha, keys: [resource], argv: [val] }
+          @redis.with { |conn| conn.evalsha Scripts::UNLOCK_SCRIPT_SHA, keys: [resource], argv: [val] }
         end
       rescue
         # Nothing to do, unlocking is just a best-effort attempt.
@@ -202,7 +184,7 @@ module Redlock
 
       def get_remaining_ttl(resource)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha @pttl_script_sha, keys: [resource] }
+          @redis.with { |conn| conn.evalsha Scripts::PTTL_SCRIPT_SHA, keys: [resource] }
         end
       rescue Redis::BaseConnectionError
         nil
@@ -211,9 +193,15 @@ module Redlock
       private
 
       def load_scripts
-        @unlock_script_sha = @redis.with { |conn| conn.script(:load, UNLOCK_SCRIPT) }
-        @lock_script_sha = @redis.with { |conn| conn.script(:load, LOCK_SCRIPT) }
-        @pttl_script_sha = @redis.with { |conn| conn.script(:load, PTTL_SCRIPT) }
+        scripts = [
+          Scripts::UNLOCK_SCRIPT,
+          Scripts::LOCK_SCRIPT,
+          Scripts::PTTL_SCRIPT
+        ]
+
+        scripts.each do |script|
+          @redis.with { |conn| conn.script(:load, script) }
+        end
       end
 
       def recover_from_script_flush
@@ -236,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(attempt_retry_delay(attempt_number)) 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
@@ -249,15 +238,18 @@ module Redlock
       false
     end
 
-    def attempt_retry_delay(attempt_number)
+    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)
+        if retry_delay.respond_to?(:call)
+          retry_delay.call(attempt_number)
         else
-          @retry_delay
+          retry_delay
         end
 
-      (retry_delay + rand(@retry_jitter)).to_f / 1000
+      (retry_delay + rand(retry_jitter)).to_f / 1000
     end
 
     def lock_instances(resource, ttl, options)

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/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '1.2.1'
+  VERSION = '1.2.2'
 end

data/lib/redlock.rb

@@ -2,6 +2,7 @@ require 'redlock/version'
 
 module Redlock
   autoload :Client, 'redlock/client'
+  autoload :Scripts, 'redlock/scripts'
 
   class LockError < StandardError
     def initialize(resource)

data/redlock.gemspec

@@ -15,7 +15,6 @@ Gem::Specification.new do |spec|
   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']
 

data/spec/client_spec.rb

@@ -44,6 +44,15 @@ RSpec.describe Redlock::Client do
       expect(resource_key).to_not be_lockable(lock_manager, ttl)
       lock_manager.unlock(lock_info)
     end
+
+    it 'does not load scripts' do
+      redis_client.script(:flush)
+
+      pool = ConnectionPool.new { Redis.new(url: "redis://#{redis1_host}:#{redis1_port}") }
+      redlock = Redlock::Client.new([pool])
+
+      expect(redis_client.info["number_of_cached_scripts"]).to eq("0")
+    end
   end
 
   describe 'lock' do
@@ -195,6 +204,41 @@ RSpec.describe Redlock::Client do
         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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-08 00:00:00.000000000 Z
+date: 2021-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -130,6 +130,7 @@ files:
 - ".travis.yml"
 - CONTRIBUTORS
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - Makefile
 - README.md
@@ -138,6 +139,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
@@ -163,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.