redis_queued_locks 1.16.2 → 1.18.0

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 # NOTE: Lock Series PoC
-# steep:ignore
 # rubocop:disable all
 # @api private
 # @since 1.16.0
@@ -15,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,
@@ -53,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
@@ -73,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
 
@@ -129,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 =
@@ -180,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
@@ -204,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
@@ -211,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
         )
 
@@ -239,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,
@@ -258,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
 
@@ -275,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,
@@ -322,7 +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
-# steep:ignore
 # rubocop:enable all

data/lib/redis_queued_locks/acquirer/locks.rb

@@ -2,7 +2,10 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::Locks
+  # rubocop:disable Metrics/ClassLength
   class << self
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
@@ -23,9 +26,11 @@ module RedisQueuedLocks::Acquirer::Locks
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
     # @return [Set<String>]
+    #   - (RW) read locks are represented by their lock keys (`rql:lock:<lock_name>`) too;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def scan_locks(redis_client, scan_size)
       Set.new.tap do |lock_keys|
         redis_client.scan(
@@ -36,19 +41,33 @@ module RedisQueuedLocks::Acquirer::Locks
           # TODO: reduce unnecessary iterations
           lock_keys.add(lock_key)
         end
+
+        # NOTE: (RW) read locks (readers registries can contain expired read locks only)
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+          count: scan_size
+        ) do |lock_readers_key|
+          # TODO: reduce unnecessary iterations
+          lock_keys.add(RedisQueuedLocks::Resource.lock_key_from_readers(lock_readers_key))
+        end
       end
     end
 
+    # NOTE:
+    #   - the lock info is extracted by the module itself with the same approach as in `LockInfo`:
+    #     public operation modules do not reuse each other (they share logic via `Resource`,
+    #     `Utilities`), so the similar logic is duplicated on purpose;
+    #
     # @param redis_client [RedisClient]
     # @param lock_keys [Set<String>]
     # @return [Set<Hash<Symbol,Any>>]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.9.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
-      # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
       Set.new.tap do |seeded_locks|
         # rubocop:disable Layout/LineLength
         # @type var seeded_locks: Set[{ lock: String, status: :released|:alive, info: Hash[String,untyped] }]
@@ -58,10 +77,16 @@ module RedisQueuedLocks::Acquirer::Locks
         lock_keys.each do |lock_key|
           # Step 1: extract lock info from redis
 
-          # @type var lock_info: Hash[String,String|Float|Integer]
+          # NOTE: (RW) readers registry of the lock
+          lock_name = lock_key.delete_prefix('rql:lock:')
+          lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+
+          # @type var lock_info: RedisQueuedLocks::Acquirer::Locks::lockInfo
           lock_info = 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.yield_self do |result| # Step 2: format the result
             # Step 2.X: lock is released
             if result == nil
@@ -73,16 +98,22 @@ module RedisQueuedLocks::Acquirer::Locks
               #   - result[1] (PTTL) (Integer)
               #     => (without any mutation, integer is atomic)
 
-              # @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] # NOTE: HGETALL result (hash)
               pttl_cmd_res = result[1] # NOTE: PTTL result (integer)
 
-              # Step 2.Y: lock is released
+              # Step 2.Y: write lock is released
               if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
-                {} #: Hash[String,String|Float|Integer]
+                # NOTE: (RW) read locks (or nothing if there are no live read locks)
+                read_lock_info(
+                  redis_client, lock_name, lock_key, result[2], result[3]
+                ) || {} #: Hash[String,String|Float|Integer]
               else
                 # Step 2.Z: lock is alive => format received info + add additional rem_ttl info
                 hget_cmd_res.tap do |lock_data|
+                  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)
@@ -109,5 +140,71 @@ module RedisQueuedLocks::Acquirer::Locks
       end
     end
     # rubocop:enable Metrics/MethodLength
+
+    # Formats live read locks of the lock (expired read locks are ignored).
+    #
+    # NOTE: the same approach as in `LockInfo` (duplicated on purpose: operation modules are
+    #   independent of each other, see `extract_locks_info`);
+    #
+    # @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
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/queue_info.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result
@@ -12,41 +13,69 @@ module RedisQueuedLocks::Acquirer::QueueInfo
     #
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Hash<String,Array<Hash<String,String|Numeric>>,NilClass]
-    #   - `nil` is returned when lock queue does not exist;
+    # @return [Hash<String,String|Array<Hash<String,String|Numeric>>,NilClass]
+    #   - `nil` is returned when lock queues (write and read) do not exist;
     #   - result format: {
     #     "lock_queue" => "rql:lock_queue:your_lock_name", # lock queue key in redis,
     #     "queue" => [
-    #       { "acq_id" => "rql:acq:123/456/789/987/identity", "score" => 123.456 },
-    #       { "acq_id" => "rql:acq:123/686/789/987/identity", "score" => 456.789 },
+    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "write" },
+    #       { "acq_id" => "rql:acq:123/686/789/987/id", "score" => 456.789, "rw_mode" => "write" },
     #       ...
-    #     ] # ordered set (by score) with information about an acquirer and their position in queue
+    #     ] # ordered set (by score) with information about an acquirer, their position in queue
+    #       # and the requested lock mode
+    #     <additional keys when the queue of read lock requests exists>:
+    #     "read_lock_queue" => "rql:lock_read_queue:your_lock_name", # read lock queue key in redis
+    #     "read_queue" => [
+    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "read" },
+    #       ...
+    #     ] # read lock requests (positions are comparable with the write lock request positions)
     #   }
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def queue_info(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
 
       result = redis_client.pipelined do |pipeline|
         pipeline.call('EXISTS', lock_key_queue)
         pipeline.call('ZRANGE', lock_key_queue, '0', '-1', 'WITHSCORES')
+        pipeline.call('EXISTS', read_lock_key_queue)
+        pipeline.call('ZRANGE', read_lock_key_queue, '0', '-1', 'WITHSCORES')
       end
 
-      # @type var result: [Integer,Array[[String,Integer|Float]]]
+      # rubocop:disable Layout/LineLength
+      # @type var result: [Integer,Array[[String,Integer|Float]],Integer,Array[[String,Integer|Float]]]
+      # rubocop:enable Layout/LineLength
       exists_cmd_res = result[0]
       zrange_cmd_res = result[1]
+      read_exists_cmd_res = result[2]
+      read_zrange_cmd_res = result[3]
 
-      if exists_cmd_res == 1
+      if exists_cmd_res == 1 || read_exists_cmd_res == 1
         # NOTE: queue existed during the piepline invocation
-        {
+        # @type var queue_info: RedisQueuedLocks::Acquirer::QueueInfo::queueInfo
+        queue_info = {
           'lock_queue' => lock_key_queue,
-          'queue' => zrange_cmd_res.map { |val| { 'acq_id' => val[0], 'score' => val[1] } }
+          'queue' => zrange_cmd_res.map do |val|
+            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'write' }
+          end
         }
+        # NOTE: (RW) the queue of read lock requests
+        if read_exists_cmd_res == 1
+          queue_info['read_lock_queue'] = read_lock_key_queue
+          queue_info['read_queue'] = read_zrange_cmd_res.map do |val|
+            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'read' }
+          end
+        end
+        queue_info
       else
         # NOTE: queue did not exist during the pipeline invocation
         nil
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquirer/queues.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::Queues
   class << self
     # @param redis_client [RedisClient]
@@ -23,9 +24,11 @@ module RedisQueuedLocks::Acquirer::Queues
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
     # @return [Set<String>]
+    #   - (RW) queues of read lock requests are included;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def scan_queues(redis_client, scan_size)
       Set.new.tap do |lock_queues|
         # @type var lock_queues: Set[String]
@@ -38,21 +41,40 @@ module RedisQueuedLocks::Acquirer::Queues
           # @type var lock_queue: String
           lock_queues.add(lock_queue)
         end
+
+        # NOTE: (RW) queues of read lock requests
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+          count: scan_size
+        ) do |read_lock_queue|
+          # TODO: reduce unnecessary iterations
+          # @type var read_lock_queue: String
+          lock_queues.add(read_lock_queue)
+        end
       end
     end
 
     # @param redis_client [RedisClient]
     # @param lock_queues [Set<String>]
     # @return [Set<Hash<Symbol,Any>>]
+    #   - each request: `{ 'acq_id' => String, 'score' => Float, 'rw_mode' => 'read'/'write' }`;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def extract_queues_info(redis_client, lock_queues)
-      # TODO: refactor with RedisQueuedLocks::Acquier::QueueInfo
+      # NOTE: the same approach as in `QueueInfo` (duplicated on purpose: public operation modules
+      #   do not reuse each other, they share logic via `Resource`, `Utilities`);
       Set.new.tap do |seeded_queues|
         # Step X: iterate over each lock queue and extract their info
         # @type var seeded_queues: Set[Hash[Symbol,untyped]]
         lock_queues.each do |lock_queue|
+          # NOTE:
+          #   - (RW) the mode of the requests of the queue (`'read'` or `'write'`);
+          #   - lock queues are scanned by the lock queue patterns, so the mode is never `nil`;
+          rw_mode = RedisQueuedLocks::Resource.lock_queue_rw_mode(lock_queue) #: String
+
           # Step 1: extract lock queue info from reids
           queue_info = redis_client.pipelined do |pipeline|
             pipeline.call('EXISTS', lock_queue)
@@ -64,14 +86,16 @@ module RedisQueuedLocks::Acquirer::Queues
             zrange_cmd_res = result[1]
 
             if exists_cmd_res == 1 # Step 2.X: lock queue existed during the piepline invocation
-              zrange_cmd_res.map { |val| { 'acq_id' => val[0], 'score' => val[1] } }
+              zrange_cmd_res.map do |val|
+                { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => rw_mode }
+              end
             else
               # Step 2.Y: lock queue did not exist during the pipeline invocation
-              [] #: Array[Hash[String,Float]]
+              [] #: Array[Hash[String,String|Float]]
             end
           end
 
-          # @type var queue_info: Array[Hash[String,Float]]
+          # @type var queue_info: Array[Hash[String,String|Float]]
 
           # Step 3: push the lock queue info to the result store
           seeded_queues << {

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -10,6 +10,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     # Release all locks:
     # - 1. clear all lock queus: drop them all from Redis database by the lock queue pattern;
     # - 2. delete all locks: drop lock keys from Redis by the lock key pattern;
+    # - 3. (RW) clear all read lock queues and drop all read locks (readers registries and data);
     #
     # @param redis [RedisClient]
     #   Redis connection client.
@@ -71,7 +72,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.14.0
+    # @version 1.18.0
     def release_all_locks(
       redis,
       batch_size,
@@ -129,6 +130,8 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def fully_release_all_locks(redis, batch_size)
       result = redis.with do |rconn|
         rconn.pipelined do |pipeline|
@@ -151,10 +154,41 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
             # TODO: reduce unnecessary iterations
             pipeline.call('EXPIRE', lock_key, '0')
           end
+
+          # Step C (RW): release all read lock queues
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+            count: batch_size
+          ) do |read_lock_queue|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', read_lock_queue, '0')
+          end
+
+          # Step D (RW): release all read locks
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+            count: batch_size
+          ) do |lock_readers|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', lock_readers, '0')
+          end
+
+          # Step E (RW): release all read lock data
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::READ_LOCK_PATTERN,
+            count: batch_size
+          ) do |read_lock|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', read_lock, '0')
+          end
         end
       end
 
       { ok: true, result: { rel_key_cnt: result.sum } }
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end