redlock 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 679d1c44fcda7a2eaa70bdfe38c30e4ee79e417bef0b3ce064aceaf0a9cc0bbb
-  data.tar.gz: 48b6a41c4cc27b8ff8878647dd494a6b87e3b17e540b75d8699e32d4ee982aa5
+  metadata.gz: 8bdda4faebf87c2d1fb0026a3142497d5ae14092340bce6e35e46f51635e5c6a
+  data.tar.gz: a9f5636898a2a3ece98b95a286bd88f417e68d119b1f1ad60bd75b5d1da94baf
 SHA512:
-  metadata.gz: a31815a7da2fa6f5c3af35734294cdb34fdfba19dc12eaf25abe950db65be1356afc397ff29a73823d267d99d0069f86651385c1e262da6ced7541345212abda
-  data.tar.gz: cd4e41fe60732180b4b5f3d848715954074f8a063c1513c89e73a37311d5d4c0d8fbe1bbd92b063955324929f07bf59232040de104bfeb14d18837d297910d59
+  metadata.gz: 0b10ec10f00ce9282d604b1d0c8a2e845d8d95a6684a5a235d6d39b598efa6324725c4d088e8016b11d473b0195a1e29a451e79fad115f04f6b217493be297cf
+  data.tar.gz: e1d54bb8bb8a108e0989d1c11baa44cbfc4c971029fb23819d000758b42739698342ef803a826990757c888d113fb8a49663df1f3812603965c5498361596f86

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/README.md

@@ -15,7 +15,8 @@ This is an implementation of a proposed [distributed lock algorithm with Redis](
 
 ## Compatibility
 
-Redlock works with Redis versions 6.0 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
 

data/lib/redlock/client.rb

@@ -4,6 +4,15 @@ require 'securerandom'
 module Redlock
   include Scripts
 
+  class LockAcquisitionError < StandardError
+    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"
@@ -168,13 +177,17 @@ module Redlock
 
       def lock(resource, val, ttl, allow_new_lock)
         recover_from_script_flush do
-          @redis.call('EVALSHA', Scripts::LOCK_SCRIPT_SHA, 1, resource, val, ttl, allow_new_lock)
+          @redis.with { |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.call('EVALSHA', Scripts::UNLOCK_SCRIPT_SHA, 1, resource, val)
+          @redis.with { |conn|
+            conn.call('EVALSHA', Scripts::UNLOCK_SCRIPT_SHA, 1, resource, val)
+          }
         end
       rescue
         # Nothing to do, unlocking is just a best-effort attempt.
@@ -182,7 +195,9 @@ module Redlock
 
       def get_remaining_ttl(resource)
         recover_from_script_flush do
-          @redis.call('EVALSHA', Scripts::PTTL_SCRIPT_SHA, 1, resource)
+          @redis.with { |conn|
+            conn.call('EVALSHA', Scripts::PTTL_SCRIPT_SHA, 1, resource)
+          }
         end
       rescue RedisClient::ConnectionError
         nil
@@ -226,6 +241,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.
@@ -233,8 +249,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
 
@@ -255,9 +275,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)
@@ -266,6 +292,11 @@ module Redlock
         { validity: validity, resource: resource, value: value }
       else
         @servers.each { |s| s.unlock(resource, value) }
+
+        if errors.size >= @quorum
+          raise LockAcquisitionError.new('Too many Redis errors prevented lock acquisition', errors)
+        end
+
         false
       end
     end

data/lib/redlock/version.rb

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

data/redlock.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'redis-client'
+  spec.add_dependency 'redis-client', '~> 0.14.1'
 
   spec.add_development_dependency 'connection_pool', '~> 2.2'
   spec.add_development_dependency 'coveralls', '~> 0.8'

data/spec/client_spec.rb

@@ -5,7 +5,21 @@ 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_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 }
@@ -37,9 +51,10 @@ RSpec.describe Redlock::Client do
 
     it 'accepts ConnectionPool objects' do
       pool = ConnectionPool.new { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
-      redlock = Redlock::Client.new([pool])
+      _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
@@ -48,7 +63,7 @@ RSpec.describe Redlock::Client do
       redis_client.call('SCRIPT', 'FLUSH')
 
       pool = ConnectionPool.new { RedisClient.new(url: "redis://#{redis1_host}:#{redis1_port}") }
-      redlock = Redlock::Client.new([pool])
+      _redlock = Redlock::Client.new([pool])
 
       raw_info = redis_client.call('INFO')
       number_of_cached_scripts = raw_info[/number_of_cached_scripts\:\d+/].split(':').last
@@ -61,6 +76,38 @@ 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(Redlock::LockAcquisitionError)
+        end
+      end
+
       it 'locks' do
         @lock_info = lock_manager.lock(resource_key, ttl)
 
@@ -197,7 +244,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|
@@ -251,7 +298,10 @@ RSpec.describe Redlock::Client do
 
         expect {
           lock_manager.lock(resource_key, ttl)
-        }.to raise_error(RedisClient::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
 
@@ -263,7 +313,10 @@ RSpec.describe Redlock::Client do
         redis_instance.instance_variable_set(:@redis, unreachable_redis)
         expect {
           lock_manager.lock(resource_key, ttl)
-        }.to raise_error(RedisClient::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
@@ -272,7 +325,9 @@ 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).call('SCRIPT', 'FLUSH')
+        @manipulated_instance.instance_variable_get(:@redis).with { |conn|
+          conn.call('SCRIPT', 'FLUSH')
+        }
       end
 
       it 'does not raise a RedisClient::CommandError: NOSCRIPT error' do
@@ -291,11 +346,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
 
@@ -475,7 +534,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,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-09 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.1
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
@@ -96,22 +96,22 @@ dependencies:
   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.0.0
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
 email:
 - leandro.ribeiro.moreira@gmail.com
@@ -122,6 +122,7 @@ files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - CONTRIBUTORS
 - Gemfile
 - LICENSE
@@ -158,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.