redis_queued_locks 1.17.0 → 1.18.0

data/lib/redis_queued_locks/acquirer/is_locked.rb

@@ -2,17 +2,34 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsLocked
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Boolean]
+    # @return [Boolean] Is the lock obtained by a writer or by any reader (live read lock).
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def locked?(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
-      redis_client.call('EXISTS', lock_key) == 1
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+
+      # @type var result: [Integer, Array[String], Array[[String, Float]]]
+      result = redis_client.pipelined do |pipeline|
+        pipeline.call('EXISTS', lock_key)
+        pipeline.call('TIME')
+        pipeline.call('ZRANGE', lock_readers_key, '-1', '-1', 'WITHSCORES')
+      end
+
+      # NOTE: write lock
+      return true if result[0] == 1
+
+      # NOTE: (RW) read lock (expired read locks can live in the readers registry till the cleanup)
+      longest_read_lock = result[2].first
+      longest_read_lock != nil &&
+        longest_read_lock[1] > RedisQueuedLocks::Resource.redis_time_ms(result[1])
     end
   end
 end

data/lib/redis_queued_locks/acquirer/is_queued.rb

@@ -2,17 +2,21 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsQueued
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Boolean]
+    # @return [Boolean] Are there any write or read lock requests.
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def queued?(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
-      redis_client.call('EXISTS', lock_key_queue) == 1
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+      # NOTE: EXISTS returns the number of existing keys
+      redis_client.call('EXISTS', lock_key_queue, read_lock_key_queue) > 0
     end
   end
 end

data/lib/redis_queued_locks/acquirer/lock_info.rb

@@ -2,14 +2,16 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::LockInfo
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Hash<String,String|Numeric>,NilClass]
-    #   - `nil` is returned when lock key does not exist or expired;
-    #   - result format: {
+    # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+    #   - `nil` is returned when lock key does not exist or expired (and there are no read locks);
+    #   - result format (write lock): {
     #     'lock_key' => "rql:lock:your_lockname", # acquired lock key
+    #     'rw_mode' => 'write', # lock mode
     #     'acq_id' => "rql:acq:123/456/789/987/uniqstring", # lock acquirer identifier
     #     'hst_id' => "rql:hst:123/456/987/uniqstring", # lock host identifier
     #     'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
@@ -22,17 +24,36 @@ module RedisQueuedLocks::Acquirer::LockInfo
     #     'l_spc_ext_ini_ttl' => 5000, # (milliseconds) the last ttl of reentrant lock
     #     'l_spc_ext_ts' => 123456.789 # (epoch) <extendable reentrant lock obtained at> timestamp
     #   }
+    #   - result format (read locks, when there is no write lock): {
+    #     'lock_key' => "rql:lock:your_lockname", # lock key
+    #     'rw_mode' => 'read', # lock mode
+    #     'rem_ttl' => 123456789, # remaining ttl of the longest read lock (milliseconds)
+    #     'readers' => [ # live read locks
+    #       {
+    #         'acq_id' => "rql:acq:123/456/789/987/uniqstring", # read lock acquirer identifier
+    #         'hst_id' => "rql:hst:123/456/987/uniqstring", # read lock host identifier
+    #         'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
+    #         'ini_ttl' => 123456789, # initial read lock ttl (milliseconds)
+    #         'rem_ttl' => 123456789, # remaining read lock ttl (milliseconds)
+    #         <custom metadata (`meta`) and additional keys for reentrant locks (see above)>
+    #       },
+    #       ...
+    #     ]
+    #   }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.9.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
 
       result = redis_client.pipelined do |pipeline|
         pipeline.call('HGETALL', lock_key)
         pipeline.call('PTTL', lock_key)
+        pipeline.call('TIME')
+        pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
       end
 
       if result == nil
@@ -48,16 +69,22 @@ module RedisQueuedLocks::Acquirer::LockInfo
         #     => (will be mutated further with different value types)
         #   - result[1] (PTTL) (Integer)
         #     => (without any mutation, integer is atomic)
+        #   - result[2] (TIME) (Array<String>) (redis time)
+        #   - result[3] (ZRANGE) (Array<[String,Float]>) (read locks)
 
-        # @type var result: [Hash[String,String|Float|Integer],Integer]
+        # rubocop:disable Layout/LineLength
+        # @type var result: [Hash[String,String|Float|Integer], Integer, Array[String], Array[[String, Float]]]
+        # rubocop:enable Layout/LineLength
         hget_cmd_res = result[0]
         pttl_cmd_res = result[1]
 
         if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
-          nil
+          # NOTE: (RW) there is no write lock => check read locks
+          read_lock_info(redis_client, lock_name, lock_key, result[2], result[3])
         else
           hget_cmd_res.tap do |lock_data|
             lock_data['lock_key'] = lock_key
+            lock_data['rw_mode'] = 'write'
             lock_data['ts'] = Float(lock_data['ts'])
             lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
             lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
@@ -73,5 +100,68 @@ module RedisQueuedLocks::Acquirer::LockInfo
       end
     end
     # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # Formats live read locks of the lock (expired read locks are ignored).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param redis_time [Array<String>] Result of the redis `TIME` command.
+    # @param read_locks [Array<Array<String,Float>>] Readers registry (acquirer id, expiration).
+    # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+    #   - `nil` is returned when there are no live read locks;
+    #   - each reader has the same data as the write lock (acq_id, hst_id, ts, ini_ttl, rem_ttl,
+    #     meta, reentrant lock data);
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def read_lock_info(redis_client, lock_name, lock_key, redis_time, read_locks)
+      now = RedisQueuedLocks::Resource.redis_time_ms(redis_time)
+      live_read_locks = read_locks.select { |(_acquirer_id, expiration)| expiration > now }
+      return nil if live_read_locks.empty?
+
+      # NOTE: read lock data (it can be absent if it is dropped during the read lock life)
+      # @type var read_locks_data: Array[Hash[String,String]]
+      read_locks_data = redis_client.pipelined do |pipeline|
+        live_read_locks.each do |(acquirer_id, _expiration)|
+          pipeline.call(
+            'HGETALL',
+            RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+          )
+        end
+      end
+
+      longest_rem_ttl = 0
+      readers = live_read_locks.each_with_index.map do |(acquirer_id, expiration), index|
+        rem_ttl = (expiration - now).ceil
+        longest_rem_ttl = rem_ttl if rem_ttl > longest_rem_ttl
+
+        # @type var reader: Hash[String,String|Float|Integer|nil]
+        reader = read_locks_data[index] || {}
+        reader['acq_id'] = acquirer_id
+        reader['hst_id'] ||= RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
+        reader['ts'] = Float(reader['ts']) if reader['ts']
+        reader['ini_ttl'] = Integer(reader['ini_ttl']) if reader['ini_ttl']
+        reader['rem_ttl'] = rem_ttl
+        reader['spc_cnt'] = Integer(reader['spc_cnt']) if reader['spc_cnt']
+        reader['l_spc_ts'] = Float(reader['l_spc_ts']) if reader['l_spc_ts']
+        reader['spc_ext_ttl'] = Integer(reader['spc_ext_ttl']) if reader['spc_ext_ttl']
+        reader['l_spc_ext_ini_ttl'] =
+          Integer(reader['l_spc_ext_ini_ttl']) if reader['l_spc_ext_ini_ttl']
+        reader['l_spc_ext_ts'] = Float(reader['l_spc_ext_ts']) if reader['l_spc_ext_ts']
+        reader
+      end
+
+      {
+        'lock_key' => lock_key,
+        'rw_mode' => 'read',
+        'rem_ttl' => longest_rem_ttl,
+        'readers' => readers
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb

@@ -6,12 +6,15 @@
 module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
   class << self
     # NOTE: Lock Series PoC
+    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.1
+    # @version 1.18.0
     def lock_series_obtained( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
+      rw_mode,
       ttl,
       acq_id,
       hst_id,
@@ -21,17 +24,20 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_obtained', {
-        lock_keys:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
       }) rescue nil
     end
 
     # NOTE: Lock Series PoC
+    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.1
+    # @version 1.18.0
     def lock_series_hold_and_release( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
+      rw_mode,
       ttl,
       acq_id,
       hst_id,
@@ -42,7 +48,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
-        lock_keys:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
       }) # rescue nil
     end
   end

data/lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb

@@ -6,8 +6,10 @@
 module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
   class << self
     # NOTE: Lock Series PoC
+    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.0
+    # @version 1.18.0
     def start_lock_series_obtaining( # steep:ignore
       logger,
       log_sampled,
@@ -15,23 +17,27 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
       logger.debug do
         "[redis_queued_locks.start_lock_series_obtaining] " \
-        "lock_keys => '#{lock_keys.inspect}'" \
+        "lock_keys => '#{lock_keys.inspect}' " \
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       end # rescue nil
     end
 
     # NOTE: Lock Series PoC
+    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.0
+    # @version 1.18.0
     def lock_series_obtained( # steep:ignore
       logger,
       log_sampled,
@@ -40,7 +46,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       acquirer_id,
       host_id,
       acq_time,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -51,13 +58,16 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}' " \
         "acq_time => #{acq_time} (ms)"
       end # rescue nil
     end
 
     # NOTE: Lock Series PoC
+    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.0
+    # @version 1.18.0
     def expire_lock_series( # steep:ignore
       logger,
       log_sampled,
@@ -65,7 +75,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -75,7 +86,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       end rescue nil
     end
   end

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -14,7 +14,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
   class << self
     # @api private
     # @since 1.16.0
-    # @version 1.16.2
+    # @version 1.18.0
     def lock_series_poc( # steep:ignore
       redis,
       lock_names,
@@ -52,6 +52,9 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
       instr_sample_this:,
       &block
     )
+      # NOTE: (RW) the lock mode is the same for all locks of the series
+      #   (see RedisQueuedLocks::Acquirer::AcquireLock for read_write_mode validations);
+
       case meta
       when Hash, NilClass then nil
       else
@@ -72,13 +75,14 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         key == 'spc_cnt' ||
         key == 'l_spc_ext_ini_ttl' ||
         key == 'l_spc_ext_ts' ||
-        key == 'l_spc_ts'
+        key == 'l_spc_ts' ||
+        key == 'rw_mode'
       end)
         raise(
           RedisQueuedLocks::ArgumentError,
           '`:meta` keys can not overlap reserved lock data keys ' \
           '"acq_id", "hst_id", "ts", "ini_ttl", "lock_key", "rem_ttl", "spc_cnt", ' \
-          '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts"'
+          '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts", "rw_mode"'
         )
       end
 
@@ -128,13 +132,16 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
 
       RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.start_lock_series_obtaining( # steep:ignore
         logger, log_sampled, lock_keys_for_instrumentation,
-        queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy
+        queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy,
+        read_write_mode
       )
 
       acq_start_time = RedisQueuedLocks::Utilities.clock_gettime
       successfully_acquired_locks = [] # steep:ignore
       failed_locks_and_errors = {} # steep:ignore
       failed_on_lock = nil
+      # NOTE: locks of the failed series are released once (exceptional or not)
+      is_failed_series_released = false
 
       lock_acquirement_operations.map do |lock_operation_options|
         result =
@@ -179,17 +186,11 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
                  RedisQueuedLocks::LockAcquirementTimeoutError,
                  RedisQueuedLocks::LockAcquirementRetryLimitError,
                  RedisQueuedLocks::ConflictLockObtainError => error
-            if successfully_acquired_locks.any?
-              # NOTE: release all previously acquired locks if any next lock is already locked
-              successfully_acquired_locks.each do |operation_result|
-                lock_key = RedisQueuedLocks::Resource.prepare_lock_key(operation_result[:lock_name])
-                redis.with do |conn|
-                  conn.multi(watch: [lock_key]) do |transact|
-                    transact.call('DEL', lock_key)
-                  end
-                end
-              end
-            end
+            # NOTE: release all previously acquired locks if any next lock is already locked
+            release_lock_series( # steep:ignore
+              redis, read_write_mode, successfully_acquired_locks, acquirer_id_for_instrumentation
+            )
+            is_failed_series_released = true
 
             raise(error) if raise_errors
           end
@@ -203,6 +204,13 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         else
           failed_on_lock = lock_operation_options[:lock_name]
           failed_locks_and_errors[lock_operation_options[:lock_name]] = result
+          # NOTE: release all previously acquired locks (non-exceptional failure: raise_errors: false)
+          unless is_failed_series_released
+            release_lock_series( # steep:ignore
+              redis, read_write_mode, successfully_acquired_locks, acquirer_id_for_instrumentation
+            )
+            is_failed_series_released = true
+          end
           break
         end
       end
@@ -210,16 +218,16 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
       if (successfully_acquired_locks.size == lock_names.size && (successfully_acquired_locks.all? { |res| res[:ok] }))
         acq_end_time = RedisQueuedLocks::Utilities.clock_gettime
         acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
-        ts = Time.now.to_s
+        ts = Time.now.to_f
 
         RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.lock_series_obtained( # steep:ignore
           logger, log_sampled, lock_keys_for_instrumentation,
           queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation,
-          acq_time, access_strategy
+          acq_time, access_strategy, read_write_mode
         )
 
         RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_obtained( # steep:ignore
-          instrumenter, instr_sampled, lock_keys_for_instrumentation,
+          instrumenter, instr_sampled, lock_keys_for_instrumentation, read_write_mode,
           ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, ts, acq_time, instrument
         )
 
@@ -238,6 +246,11 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
             redis,
             logger,
             lock_keys_for_instrumentation.last,
+            RedisQueuedLocks::Resource.prepare_lock_readers(lock_names.last),
+            RedisQueuedLocks::Resource.prepare_read_lock_key(
+              lock_names.last, acquirer_id_for_instrumentation
+            ),
+            read_write_mode,
             acquirer_id_for_instrumentation,
             host_id_for_instrumentation,
             access_strategy,
@@ -257,14 +270,9 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
 
           # expire locks manually
           if block_given?
-            redis.with do |conn|
-              # use transaction in order to exclude any cross-locking during the group expiration
-              conn.multi(watch: lock_keys_for_instrumentation) do |transaction|
-                lock_keys_for_instrumentation.each do |lock_key|
-                  transaction.call('EXPIRE', lock_key, '0')
-                end
-              end
-            end
+            release_lock_series( # steep:ignore
+              redis, read_write_mode, successfully_acquired_locks, acquirer_id_for_instrumentation
+            )
             is_lock_manually_released = true
           end
 
@@ -274,13 +282,15 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
 
           RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.expire_lock_series( # steep:ignore
             logger, log_sampled, lock_keys_for_instrumentation,
-            queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy
+            queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy,
+            read_write_mode
           ) if is_lock_manually_released
 
           RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_hold_and_release( # steep:ignore
             instrumenter,
             instr_sampled,
             lock_keys_for_instrumentation,
+            read_write_mode,
             ttl,
             acquirer_id_for_instrumentation,
             host_id_for_instrumentation,
@@ -321,6 +331,95 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         }
       end
     end
+
+    private
+
+    # Releases locks of the series that are obtained by the series itself:
+    #   - reentrant locks (already obtained by the outer logic of the current acquirer) are kept;
+    #   - only locks of the current acquirer are released (owner check);
+    #
+    # @param redis [RedisClient]
+    # @param read_write_mode [Symbol]
+    # @param successfully_acquired_locks [Array<Hash<Symbol,Any>>]
+    # @param acquirer_id [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.18.0
+    def release_lock_series(redis, read_write_mode, successfully_acquired_locks, acquirer_id) # steep:ignore
+      lock_names = obtained_lock_names(successfully_acquired_locks) # steep:ignore
+
+      if read_write_mode == :read
+        release_read_lock_series(redis, lock_names, acquirer_id) # steep:ignore
+      else
+        release_write_lock_series(redis, lock_names, acquirer_id) # steep:ignore
+      end
+    end
+
+    # Releases write locks of the given acquirer (compare-and-delete: the lock can be expired
+    # and obtained by another acquirer when the series logic exceeds the lock ttl).
+    #
+    # @param redis [RedisClient]
+    # @param lock_names [Array<String>]
+    # @param acquirer_id [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.18.0
+    def release_write_lock_series(redis, lock_names, acquirer_id) # steep:ignore
+      return if lock_names.empty?
+
+      redis.with do |conn|
+        lock_names.each do |lock_name|
+          lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+          conn.multi(watch: [lock_key]) do |transaction|
+            if conn.call('HGET', lock_key, 'acq_id') == acquirer_id
+              transaction.call('DEL', lock_key)
+            end
+          end
+        end
+      end
+    end
+
+    # Locks of the series that are obtained by the series itself (reentrant locks are obtained
+    # by the outer logic of the current acquirer and should be released by it).
+    #
+    # @param successfully_acquired_locks [Array<Hash<Symbol,Any>>]
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 1.18.0
+    def obtained_lock_names(successfully_acquired_locks) # steep:ignore
+      successfully_acquired_locks.filter_map do |operation_result|
+        operation_result[:lock_name] if operation_result[:result][:process] == :lock_obtaining
+      end
+    end
+
+    # Releases read locks of the given acquirer (other readers are not affected).
+    #
+    # @param redis [RedisClient]
+    # @param lock_names [Array<String>]
+    # @param acquirer_id [String]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.18.0
+    def release_read_lock_series(redis, lock_names, acquirer_id) # steep:ignore
+      return if lock_names.empty?
+
+      redis.with do |conn|
+        conn.multi do |transaction|
+          lock_names.each do |lock_name|
+            transaction.call(
+              'ZREM', RedisQueuedLocks::Resource.prepare_lock_readers(lock_name), acquirer_id
+            )
+            transaction.call(
+              'DEL', RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+            )
+          end
+        end
+      end
+    end
   end
 end
 # rubocop:enable all