redlock 1.3.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7de9b6b9d70bce2578e474bdfe8dfa15c22bb57e0c876ac7127d826a5b6ba9b4
-  data.tar.gz: c294d219107aa4a8682ba4ff303e150497ea61b2dd4abb71d3cac15e78c218bd
+  metadata.gz: 229c8a5a2a6c074810df969cd50e20bac41f8bf47e3d5714fe21975888702fb0
+  data.tar.gz: d9e1079662c2ef7ddd23d3e03696c48d6b9ae7fe37c0b65760c3a90be07bc239
 SHA512:
-  metadata.gz: b0eeead2b1307f12487603d72a7a5e00d6aba1d697a5327ac484a4fa4cc00575e0fcedd43a38aa34ee93da7322550630ad3cec158a5ef0fcf98849033c90ec85
-  data.tar.gz: 712d3c40ab8c4278f4649f373bfcb6ca4eeb2361461a48ad42d17f44a9d1becba460b82ed99f6b035232698267ad5046831230960b47171d9fa09d9ba0d4b692
+  metadata.gz: 6a3436508b649c79682b310ff57094aa06a532ebde60b193d720dcc88116166a9bacc5e60701515528ef9cf8b7946e246c2bc8341a75eb948cc23ecd1a7be8ff
+  data.tar.gz: d2fc1c15c559a684f87b08ccd1e7e3adc9988323111803c1ca66f2df5381890c09802218dc86477e1de2099bd7aafca1e5e368c9f15fd85ea9f5d433846c0928

data/.github/workflows/ci.yml

@@ -2,9 +2,9 @@ name: Ruby CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
 jobs:
   test:
@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        ruby-version: [3.1, "3.0", "2.7", "2.6", "2.5", "ruby-head"]
+        ruby-version: [3.2, 3.1, "3.0", "2.7", "ruby-head"]
 
     steps:
       - uses: actions/checkout@v2

data/.gitignore

@@ -2,3 +2,4 @@
 coverage/
 .bundle/
 dump.rdb
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,40 @@
+
+# Change Log
+All notable changes to this project will be documented in this file.
+ 
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+ 
+## [Unreleased] - yyyy-mm-dd
+ 
+Here we write upgrading notes for brands. It's a team effort to make them as
+straightforward as possible.
+ 
+### Added
+ 
+### Changed
+ 
+### Fixed
+ 
+
+## [2.0.1] - 2023-02-14
+ 
+### Added
+ 
+### Changed
+   
+### Fixed
+
+* always treat redis instance as pool-like #125
+
+## [2.0.0] - 2023-02-09
+ 
+### Added
+
+* support for redis >= 6.0
+ 
+### Changed
+
+* **BREAKING**: The library now only works with `RedisClient` instance.
+   
+### Fixed

data/Makefile

@@ -1,12 +1,9 @@
 default: test
 test:
-	docker-compose run --rm test
+	docker compose run --rm test
 
 build:
-	docker-compose run --rm test gem build redlock.gemspec
+	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 }'`
-
-updateLock:
-	docker-compose run --rm test bundle lock --update
+	docker compose run --rm test gem push `ls -lt *gem | head -n 1 | awk '{ print $$9 }'`

data/README.md

@@ -15,7 +15,8 @@ This is an implementation of a proposed [distributed lock algorithm with Redis](
 
 ## Compatibility
 
-Redlock works with Redis versions 2.6 or later.
+* It works with Redis server versions 6.0 or later.
+* Redlock >= 2.0 only works with [`RedisClient`](https://github.com/redis-rb/redis-client) client instance.
 
 ## Installation
 
@@ -151,7 +152,7 @@ lock_manager.get_remaining_ttl_for_lock(lock_info)
 
 lock_manager.unlock(lock_info)
 lock_manager.get_remaining_ttl_for_lock(lock_info)
-#=> nil 
+#=> 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:
@@ -164,25 +165,40 @@ lock_info = lock_manager.lock(resource, 2000)
 lock_manager.locked?(resource)
 #=> true
 lock_manager.get_remaining_ttl_for_resource(resource)
-#=> 1975 
+#=> 1975
 
 # Sometime later
 lock_manager.locked?(resource)
 #=> false
 lock_manager.get_remaining_ttl_for_resource(resource)
-#=> nil 
+#=> nil
 ```
 
 ## Redis client configuration
 
-`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.
+`Redlock::Client` expects URLs, or configurations 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)
 ```
 
-Redlock works seamlessly with [redis sentinel](http://redis.io/topics/sentinel), which is supported in redis 3.2+.
+To utilize `Redlock::Client` with sentinels you can pass an instance of `RedisClient` or just a configuration hash as part of the servers array during initialization.
+
+```ruby
+config = {
+  name: "mymaster",
+  sentinels: [
+    { host: "127.0.0.1", port: 26380 },
+    { host: "127.0.0.1", port: 26381 },
+  ],
+  role: :master
+}
+client = RedisClient.sentinel(**config).new_client
+servers = [ config, client ]
+redlock = Redlock::Client.new(servers)
+```
+Redlock supports the same configuration hash as `RedisClient`.
 
 ## Redlock configuration
 

data/lib/redlock/client.rb

@@ -1,9 +1,19 @@
-require 'redis'
+require 'monitor'
+require 'redis-client'
 require 'securerandom'
 
 module Redlock
   include Scripts
 
+  class LockAcquisitionError < LockError
+    attr_reader :errors
+
+    def initialize(message, errors)
+      super(message)
+      @errors = errors
+    end
+  end
+
   class Client
     DEFAULT_REDIS_HOST    = ENV["DEFAULT_REDIS_HOST"] || "localhost"
     DEFAULT_REDIS_PORT    = ENV["DEFAULT_REDIS_PORT"] || "6379"
@@ -147,34 +157,62 @@ module Redlock
     private
 
     class RedisInstance
-      module ConnectionPoolLike
-        def with
-          yield self
-        end
-      end
-
       def initialize(connection)
-        if connection.respond_to?(:with)
+        @monitor = Monitor.new
+
+        if connection.respond_to?(:call)
           @redis = connection
         else
           if connection.respond_to?(:client)
             @redis = connection
+          elsif connection.respond_to?(:key?)
+            @redis = initialize_client(connection)
           else
-            @redis = Redis.new(connection)
+            @redis = connection
+          end
+        end
+      end
+
+      def initialize_client(options)
+        if options.key?(:sentinels)
+          if url = options.delete(:url)
+            uri = URI.parse(url)
+            if !options.key?(:name) && uri.host
+              options[:name] = uri.host
+            end
+
+            if !options.key?(:password) && uri.password && !uri.password.empty?
+              options[:password] = uri.password
+            end
+
+            if !options.key?(:username) && uri.user && !uri.user.empty?
+              options[:username] = uri.user
+            end
           end
-          @redis.extend(ConnectionPoolLike)
+
+          RedisClient.sentinel(**options).new_client
+        else
+          RedisClient.config(**options).new_client
         end
       end
 
+      def synchronize
+        @monitor.synchronize { @redis.then { |connection| yield(connection) } }
+      end
+
       def lock(resource, val, ttl, allow_new_lock)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha Scripts::LOCK_SCRIPT_SHA, keys: [resource], argv: [val, ttl, allow_new_lock] }
+          synchronize { |conn|
+            conn.call('EVALSHA', Scripts::LOCK_SCRIPT_SHA, 1, resource, val, ttl, allow_new_lock)
+          }
         end
       end
 
       def unlock(resource, val)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha Scripts::UNLOCK_SCRIPT_SHA, keys: [resource], argv: [val] }
+          synchronize { |conn|
+            conn.call('EVALSHA', Scripts::UNLOCK_SCRIPT_SHA, 1, resource, val)
+          }
         end
       rescue
         # Nothing to do, unlocking is just a best-effort attempt.
@@ -182,9 +220,11 @@ module Redlock
 
       def get_remaining_ttl(resource)
         recover_from_script_flush do
-          @redis.with { |conn| conn.evalsha Scripts::PTTL_SCRIPT_SHA, keys: [resource] }
+          synchronize { |conn|
+            conn.call('EVALSHA', Scripts::PTTL_SCRIPT_SHA, 1, resource)
+          }
         end
-      rescue Redis::BaseConnectionError
+      rescue RedisClient::ConnectionError
         nil
       end
 
@@ -197,8 +237,24 @@ module Redlock
           Scripts::PTTL_SCRIPT
         ]
 
-        scripts.each do |script|
-          @redis.with { |conn| conn.script(:load, script) }
+        synchronize do |connnection|
+          scripts.each do |script|
+            connnection.call('SCRIPT', 'LOAD', script)
+          end
+        end
+      end
+
+      # Exception classes that may be raised for NOSCRIPT errors.
+      # RedisClient::CommandError is raised when using redis-client directly.
+      # Redis::CommandError (or its subclass Redis::NoScriptError) is raised
+      # when using the redis gem wrapper.
+      # See: https://github.com/leandromoreira/redlock-rb/issues/124
+      # See: https://github.com/leandromoreira/redlock-rb/issues/148
+      def script_error_classes
+        @script_error_classes ||= begin
+          classes = [RedisClient::CommandError]
+          classes << Redis::CommandError if defined?(Redis::CommandError)
+          classes
         end
       end
 
@@ -206,7 +262,7 @@ module Redlock
         retry_on_noscript = true
         begin
           yield
-        rescue Redis::CommandError => e
+        rescue *script_error_classes => 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.
@@ -224,6 +280,7 @@ module Redlock
     def try_lock_instances(resource, ttl, options)
       retry_count = options[:retry_count] || @retry_count
       tries = options[:extend] ? 1 : (retry_count + 1)
+      last_error = nil
 
       tries.times do |attempt_number|
         # Wait a random delay before retrying.
@@ -231,8 +288,12 @@ module Redlock
 
         lock_info = lock_instances(resource, ttl, options)
         return lock_info if lock_info
+      rescue => e
+        last_error = e
       end
 
+      raise last_error if last_error
+
       false
     end
 
@@ -253,9 +314,15 @@ module Redlock
     def lock_instances(resource, ttl, options)
       value = (options[:extend] || { value: SecureRandom.uuid })[:value]
       allow_new_lock = options[:extend_only_if_locked] ? 'no' : 'yes'
+      errors = []
 
       locked, time_elapsed = timed do
-        @servers.select { |s| s.lock resource, value, ttl, allow_new_lock }.size
+        @servers.count do |s|
+          s.lock(resource, value, ttl, allow_new_lock)
+        rescue => e
+          errors << e
+          false
+        end
       end
 
       validity = ttl - time_elapsed - drift(ttl)
@@ -264,6 +331,12 @@ module Redlock
         { validity: validity, resource: resource, value: value }
       else
         @servers.each { |s| s.unlock(resource, value) }
+
+        if errors.size >= @quorum
+          err_msgs = errors.map { |e| "#{e.class}: #{e.message}" }.join("\n")
+          raise LockAcquisitionError.new("Too many Redis errors prevented lock acquisition:\n#{err_msgs}", errors)
+        end
+
         false
       end
     end

data/lib/redlock/testing.rb

@@ -41,7 +41,7 @@ module Redlock
 
       def load_scripts
         load_scripts_without_testing unless Redlock::Client.testing_mode == :bypass
-      rescue Redis::CommandError
+      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.3.2'
+  VERSION = '2.1.0'
 end

data/redlock.gemspec

@@ -5,24 +5,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'redlock/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'redlock'
-  spec.version       = Redlock::VERSION
-  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.name                  = 'redlock'
+  spec.version               = Redlock::VERSION
+  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.required_ruby_version = '>= 2.7.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'redis', '>= 3.0.0', '< 6.0'
+  spec.add_dependency 'redis-client', '>= 0.14.1', '< 1.0.0'
 
   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 'coveralls_reborn', '~> 0.29'
+  spec.add_development_dependency 'json', '>= 2.3.0'
   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,13 +1,26 @@
 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(url: "redis://#{redis1_host}:#{redis1_port}") }
+  let(:redis_urls_or_clients) {
+    urls = Redlock::Client::DEFAULT_REDIS_URLS
+    if rand(0..1).zero?
+      RSpec.configuration.reporter.message "variant: client urls"
+      urls
+    else
+      RSpec.configuration.reporter.message "variant: client objects"
+      urls.map {|url|
+        ConnectionPool.new { RedisClient.new(url: url) }
+      }
+    end
+  }
+  let(:lock_manager) {
+    Redlock::Client.new(redis_urls_or_clients, lock_manager_opts)
+  }
+  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" }
@@ -17,41 +30,51 @@ RSpec.describe Redlock::Client do
   let(:redis3_host) { ENV["REDIS3_HOST"] || "127.0.0.1" }
   let(:redis3_port) { ENV["REDIS3_PORT"] || "6379" }
   let(:unreachable_redis) {
-    redis = Redis.new(url: 'redis://localhost:46864')
-    def redis.with
-      yield self
-    end
-    redis
+    RedisClient.new(url: 'redis://localhost:46864')
   }
 
   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 { Redis.new(url: "redis://#{redis1_host}:#{redis1_port}") }
-      redlock = Redlock::Client.new([pool])
+      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(lock_info).to be_a(Hash)
+      expect(resource_key).to_not be_lockable(lock_manager, ttl)
+      lock_manager.unlock(lock_info)
+    end
+
+    it 'accepts Configuration hashes' do
+      config = { url: "redis://#{redis1_host}:#{redis1_port}" }
+      _redlock = Redlock::Client.new([config])
 
       lock_info = lock_manager.lock(resource_key, ttl)
+      expect(lock_info).to be_a(Hash)
       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)
+      redis_client.call('SCRIPT', 'FLUSH')
+
+      pool = ConnectionPool.new { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
+      _redlock = Redlock::Client.new([pool])
 
-      pool = ConnectionPool.new { Redis.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(redis_client.info["number_of_cached_scripts"]).to eq("0")
+      expect(number_of_cached_scripts).to eq("0")
     end
   end
 
@@ -59,6 +82,44 @@ RSpec.describe Redlock::Client do
     context 'when lock is available' do
       after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
 
+      context 'when redis connection error occurs' do
+        let(:servers_with_quorum) {
+          [
+            "redis://#{redis1_host}:#{redis1_port}",
+            "redis://#{redis2_host}:#{redis2_port}",
+            unreachable_redis
+          ]
+        }
+
+        let(:servers_without_quorum) {
+          [
+            "redis://#{redis1_host}:#{redis1_port}",
+            unreachable_redis,
+            unreachable_redis
+          ]
+        }
+
+        it 'locks if majority of redis instances are available' do
+          redlock = Redlock::Client.new(servers_with_quorum)
+
+          expect(redlock.lock(resource_key, ttl)).to be_truthy
+        end
+
+        it 'fails to acquire a lock if majority of Redis instances are not available' do
+          redlock = Redlock::Client.new(servers_without_quorum)
+
+          expect {
+            redlock.lock(resource_key, ttl)
+          }.to raise_error do |error|
+            expect(error).to be_a(Redlock::LockAcquisitionError)
+            expect(error.message).to include('Too many Redis errors prevented lock acquisition')
+            expect(error.message).to include('RedisClient::CannotConnectError')
+            expect(error.message).to include('Connection refused')
+            expect(error.errors.size).to eq(2)
+          end
+        end
+      end
+
       it 'locks' do
         @lock_info = lock_manager.lock(resource_key, ttl)
 
@@ -74,7 +135,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
@@ -106,7 +167,7 @@ RSpec.describe Redlock::Client do
 
         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_locked flag is not given' do
@@ -195,7 +256,7 @@ RSpec.describe Redlock::Client do
           2000
         end
 
-        lock_manager = Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, retry_count: 1, retry_delay: retry_delay)
+        lock_manager = Redlock::Client.new(redis_urls_or_clients, retry_count: 1, retry_delay: retry_delay)
         another_lock_info = lock_manager.lock(resource_key, ttl)
 
         expect(lock_manager).to receive(:sleep) do |sleep|
@@ -249,7 +310,10 @@ RSpec.describe Redlock::Client do
 
         expect {
           lock_manager.lock(resource_key, ttl)
-        }.to raise_error(Redis::CannotConnectError)
+        }.to raise_error(Redlock::LockAcquisitionError) do |e|
+          expect(e.errors[0]).to be_a(RedisClient::CannotConnectError)
+          expect(e.errors.count).to eq 1
+        end
       end
     end
 
@@ -261,7 +325,10 @@ RSpec.describe Redlock::Client do
         redis_instance.instance_variable_set(:@redis, unreachable_redis)
         expect {
           lock_manager.lock(resource_key, ttl)
-        }.to raise_error(Redis::CannotConnectError)
+        }.to raise_error(Redlock::LockAcquisitionError) do |e|
+          expect(e.errors[0]).to be_a(RedisClient::CannotConnectError)
+          expect(e.errors.count).to eq 1
+        end
         redis_instance.instance_variable_set(:@redis, old_redis)
         expect(lock_manager.lock(resource_key, ttl)).to be_truthy
       end
@@ -270,10 +337,12 @@ 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).with { |conn|
+          conn.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
@@ -289,11 +358,15 @@ RSpec.describe Redlock::Client do
           # This time we do not pass it through to Redis, in order to simulate a passing
           # call to LOAD SCRIPT followed by another NOSCRIPT error. Imagine someone
           # repeatedly calling SCRIPT FLUSH on our Redis instance.
-          expect(@manipulated_instance).to receive(:load_scripts)
+          expect(@manipulated_instance).to receive(:load_scripts).exactly(8).times
 
           expect {
             lock_manager.lock(resource_key, ttl)
-          }.to raise_error(/NOSCRIPT/)
+          }.to raise_error(Redlock::LockAcquisitionError) do |e|
+            expect(e.errors[0]).to be_a(RedisClient::CommandError)
+            expect(e.errors[0].message).to match(/NOSCRIPT/)
+            expect(e.errors.count).to eq 1
+          end
         end
       end
 
@@ -304,6 +377,108 @@ RSpec.describe Redlock::Client do
       end
     end
 
+    context 'when using the redis gem (Redis::CommandError)' do
+      # The redis gem raises Redis::CommandError (or Redis::NoScriptError) instead of
+      # RedisClient::CommandError. This tests that both error hierarchies are handled.
+      # See: https://github.com/leandromoreira/redlock-rb/issues/124
+      # See: https://github.com/leandromoreira/redlock-rb/issues/148
+
+      before(:all) do
+        # Define Redis::CommandError if not already defined (simulates redis gem being loaded)
+        unless defined?(Redis::CommandError)
+          module Redis
+            class CommandError < StandardError; end
+          end
+          @redis_command_error_defined_by_test = true
+        end
+      end
+
+      after(:all) do
+        # Clean up the mock class if we defined it
+        if @redis_command_error_defined_by_test
+          Redis.send(:remove_const, :CommandError)
+          Object.send(:remove_const, :Redis) if Redis.constants.empty?
+        end
+      end
+
+      describe '#script_error_classes' do
+        it 'includes RedisClient::CommandError' do
+          redis_instance = lock_manager.instance_variable_get(:@servers).first
+          expect(redis_instance.send(:script_error_classes)).to include(RedisClient::CommandError)
+        end
+
+        it 'includes Redis::CommandError when defined' do
+          redis_instance = lock_manager.instance_variable_get(:@servers).first
+          # Clear memoization to pick up the newly defined class
+          redis_instance.instance_variable_set(:@script_error_classes, nil)
+          expect(redis_instance.send(:script_error_classes)).to include(Redis::CommandError)
+        end
+      end
+
+      context 'when Redis::CommandError NOSCRIPT is raised' do
+        it 'recovers by reloading scripts' do
+          redis_instance = lock_manager.instance_variable_get(:@servers).first
+          # Clear memoization to ensure Redis::CommandError is included
+          redis_instance.instance_variable_set(:@script_error_classes, nil)
+
+          call_count = 0
+          allow(redis_instance).to receive(:synchronize).and_wrap_original do |original_method, &block|
+            call_count += 1
+            if call_count == 1
+              # First call raises Redis::CommandError with NOSCRIPT
+              raise Redis::CommandError, 'NOSCRIPT No matching script'
+            else
+              original_method.call(&block)
+            end
+          end
+
+          expect(redis_instance).to receive(:load_scripts).and_call_original
+
+          # Should recover and successfully lock
+          lock_info = lock_manager.lock(resource_key, ttl)
+          expect(lock_info).to be_truthy
+          lock_manager.unlock(lock_info) if lock_info
+        end
+
+        it 'does not retry more than once per operation' do
+          redis_instance = lock_manager.instance_variable_get(:@servers).first
+          redis_instance.instance_variable_set(:@script_error_classes, nil)
+
+          # Always raise Redis::CommandError NOSCRIPT
+          allow(redis_instance).to receive(:synchronize).and_raise(
+            Redis::CommandError, 'NOSCRIPT No matching script'
+          )
+
+          load_scripts_count = 0
+          allow(redis_instance).to receive(:load_scripts) { load_scripts_count += 1 }
+
+          expect {
+            lock_manager.lock(resource_key, ttl)
+          }.to raise_error(Redlock::LockAcquisitionError)
+
+          # Should have called load_scripts once per retry attempt (8 times total:
+          # lock + unlock for each of retry_count+1 attempts, but unlock swallows errors)
+          expect(load_scripts_count).to eq(8)
+        end
+
+        it 're-raises non-NOSCRIPT Redis::CommandError' do
+          redis_instance = lock_manager.instance_variable_get(:@servers).first
+          redis_instance.instance_variable_set(:@script_error_classes, nil)
+
+          allow(redis_instance).to receive(:synchronize).and_raise(
+            Redis::CommandError, 'ERR some other error'
+          )
+
+          expect {
+            lock_manager.lock(resource_key, ttl)
+          }.to raise_error(Redlock::LockAcquisitionError) do |e|
+            expect(e.errors[0]).to be_a(Redis::CommandError)
+            expect(e.errors[0].message).to eq('ERR some other error')
+          end
+        end
+      end
+    end
+
     describe 'block syntax' do
       context 'when lock is available' do
         it 'locks' do
@@ -473,7 +648,7 @@ RSpec.describe Redlock::Client do
 
         # Replace redis with unreachable instance
         redis_instance = lock_manager.instance_variable_get(:@servers).first
-        old_redis = redis_instance.instance_variable_get(:@redis)
+        _old_redis = redis_instance.instance_variable_get(:@redis)
         redis_instance.instance_variable_set(:@redis, unreachable_redis)
 
         expect {

data/spec/testing_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Redlock::Client do
   describe '(testing mode)' do
     describe 'try_lock_instances' do
       context 'when testing with bypass mode' do
-        before { lock_manager.testing_mode = :bypass }
+        before { Redlock::Client.testing_mode = :bypass }
 
         it 'bypasses the redis servers' do
           expect(lock_manager).to_not receive(:try_lock_instances_without_testing)
@@ -22,7 +22,7 @@ RSpec.describe Redlock::Client do
       end
 
       context 'when testing with fail mode' do
-        before { lock_manager.testing_mode = :fail }
+        before { Redlock::Client.testing_mode = :fail }
 
         it 'fails' do
           expect(lock_manager).to_not receive(:try_lock_instances_without_testing)
@@ -33,7 +33,7 @@ RSpec.describe Redlock::Client do
       end
 
       context 'when testing is disabled' do
-        before { lock_manager.testing_mode = nil }
+        before { Redlock::Client.testing_mode = nil }
 
         it 'works as usual' do
           expect(lock_manager).to receive(:try_lock_instances_without_testing)

metadata

@@ -1,35 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Leandro Moreira
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-17 00:00:00.000000000 Z
+date: 1980-01-02 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
+        version: 0.14.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 0.14.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
@@ -45,19 +44,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: coveralls_reborn
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.29'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.29'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -65,9 +64,6 @@ dependencies:
     - - ">="
       - !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
@@ -75,9 +71,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.0
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -128,9 +121,9 @@ files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - CONTRIBUTORS
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - Makefile
 - README.md
@@ -150,7 +143,6 @@ homepage: https://github.com/leandromoreira/redlock-rb
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -158,15 +150,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.
 test_files:

data/Gemfile.lock

@@ -1,62 +0,0 @@
-PATH
-  remote: .
-  specs:
-    redlock (1.3.2)
-      redis (>= 3.0.0, < 6.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    connection_pool (2.3.0)
-    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.5.0)
-    docile (1.4.0)
-    json (2.3.1)
-    rake (13.0.6)
-    redis (5.0.5)
-      redis-client (>= 0.9.0)
-    redis-client (0.10.0)
-      connection_pool
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.1)
-    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.2.1)
-    tins (1.31.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.3.7