redis_queued_locks 1.16.2 → 1.18.0

data/lib/redis_queued_locks/acquirer/release_lock.rb

@@ -11,6 +11,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     # - 1. clear lock queue: al; related processes released
     #      from the lock aquierment and should retry;
     # - 2. delete the lock: drop lock key from Redis;
+    # - 3. (RW) clear the read lock queue and drop all read locks (the readers registry);
     # It is safe because the lock obtain logic is transactional and
     # watches the original lock for changes.
     #
@@ -71,7 +72,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.14.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
@@ -89,9 +90,15 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     )
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
 
       rel_start_time = clock_gettime
-      fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: } # steep:ignore
+      # steep:ignore:start
+      fully_release_lock(
+        redis, lock_name, lock_key, lock_key_queue, read_lock_key_queue, lock_readers_key
+      ) => { ok:, result: }
+      # steep:ignore:end
 
       # @type var ok: bool
       # @type var result: Hash[Symbol,Symbol]
@@ -131,36 +138,60 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
 
     private
 
-    # Realease the lock: clear the lock queue and expire the lock.
+    # Realease the lock: clear the lock queues and expire the lock (write lock and read locks).
     #
     # @param redis [RedisClient]
+    # @param lock_name [String]
     # @param lock_key [String]
     # @param lock_key_queue [String]
+    # @param read_lock_key_queue [String]
+    # @param lock_readers_key [String]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
     #   Format: {
     #     ok: true/false,
     #     result: {
-    #       queue: :released/:nothing_to_release,
-    #       lock: :released/:nothing_to_release
+    #       queue: :released/:nothing_to_release, # (any of the lock queues)
+    #       lock: :released/:nothing_to_release # (write lock or read locks)
     #     }
     #   }
     #
     # @api private
     # @since 1.0.0
-    def fully_release_lock(redis, lock_key, lock_key_queue)
-      # @type var result: [Integer,Integer]
+    # @version 1.18.0
+    def fully_release_lock(
+      redis,
+      lock_name,
+      lock_key,
+      lock_key_queue,
+      read_lock_key_queue,
+      lock_readers_key
+    )
+      # @type var result: [Integer,Integer,Integer,Integer]
       result = redis.with do |rconn|
+        # NOTE: (RW) data of read locks (it is a data carrier only: read locks are released via
+        #   the readers registry, so the data of concurrently obtained read locks expires itself)
+        # @type var read_lock_acquirers: Array[String]
+        read_lock_acquirers = rconn.call('ZRANGE', lock_readers_key, '0', '-1')
+
         rconn.multi do |transact|
           transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
           transact.call('EXPIRE', lock_key, '0')
+          transact.call('ZREMRANGEBYSCORE', read_lock_key_queue, '-inf', '+inf')
+          transact.call('EXPIRE', lock_readers_key, '0')
+          read_lock_acquirers.each do |acquirer_id|
+            transact.call(
+              'DEL',
+              RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+            )
+          end
         end
       end
 
       {
         ok: true,
         result: {
-          queue: (result[0] != 0) ? :released : :nothing_to_release,
-          lock: (result[1] != 0) ? :released : :nothing_to_release
+          queue: (result[0] != 0 || result[2] != 0) ? :released : :nothing_to_release,
+          lock: (result[1] != 0 || result[3] != 0) ? :released : :nothing_to_release
         }
       }
     end

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -2,12 +2,16 @@
 
 # @api private
 # @since 1.14.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ReleaseLocksOf
   # @since 1.14.0
   extend RedisQueuedLocks::Utilities
 
+  # rubocop:disable Metrics/ClassLength
   class << self
-    # Release all queues and locks that belong to the given host and its associated acquirer.
+    # Release all queues and locks (write locks and read locks) that belong to the given host
+    # and its associated acquirer.
     #
     # @param refused_host_id [String]
     #   A host whose locks and queues should be released.
@@ -84,7 +88,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
     #
     # @api private
     # @since 1.14.0
-    # @version 1.15.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def release_locks_of(
       refused_host_id,
@@ -164,6 +168,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
     #
     # @api private
     # @since 1.14.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def fully_release_locks_of(
       refused_host_id,
@@ -203,6 +208,30 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
           rel_key_cnt += refused_locks.size
         end
 
+        # Step A (RW): drop read locks of the passed host/acquirer
+        #   - read locks store acquirer ids only (the host is a part of the acquirer id);
+        if RedisQueuedLocks::Resource.host_identifier_from_acquirer(refused_acquirer_id) ==
+           refused_host_id
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+            count: lock_scan_size
+          ) do |lock_readers_key|
+            res = rconn.call('ZREM', lock_readers_key, refused_acquirer_id)
+            next if res == 0
+
+            rel_key_cnt += 1
+            # NOTE: drop the read lock data
+            rconn.call(
+              'DEL',
+              RedisQueuedLocks::Resource.prepare_read_lock_key(
+                RedisQueuedLocks::Resource.lock_name_from_readers(lock_readers_key),
+                refused_acquirer_id
+              )
+            )
+          end
+        end
+
         # Step B: drop passed host/acquirer from lock queues
         rconn.scan(
           'MATCH',
@@ -212,10 +241,21 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
           res = rconn.call('ZREM', lock_queue, refused_acquirer_id)
           tch_queue_cnt += 1 if res != 0
         end
+
+        # Step B (RW): drop passed host/acquirer from read lock queues
+        rconn.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+          count: queue_scan_size
+        ) do |read_lock_queue|
+          res = rconn.call('ZREM', read_lock_queue, refused_acquirer_id)
+          tch_queue_cnt += 1 if res != 0
+        end
       end
 
       { ok: true, result: { rel_key_cnt:, tch_queue_cnt: } }
     end
   end
-  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/MethodLength, Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/release_read_lock.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.18.0
+module RedisQueuedLocks::Acquirer::ReleaseReadLock
+  # @since 1.18.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # Release the read lock of the concrete acquirer (other read locks, the write lock and
+    # lock requests are not affected): drop the acquirer from the readers registry and drop
+    # its read lock data.
+    #
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param lock_name [String]
+    #   The lock name whose read lock should be released.
+    # @param acquirer_id [String]
+    #   The read lock acquirer.
+    # @param instrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param logger [::Logger,#debug]
+    #   - Logger object used from `configuration` layer (see config['logger']);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param instrument [NilClass,Any]
+    #   - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #     with :instrument key;
+    # @param log_sampling_enabled [Boolean]
+    # @param log_sampling_percent [Integer]
+    # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param log_sample_this [Boolean]
+    # @param instr_sampling_enabled [Boolean]
+    #   - enables <instrumentaion sampling>: only the configured percent
+    #     of RQL cases will be instrumented;
+    # @param instr_sampling_percent [Integer]
+    #   - the percent of cases that should be instrumented;
+    # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+    #   - percent-based sampler that decides should be RQL case instrumented or not;
+    # @param instr_sample_this [Boolean]
+    #   - marks the method that everything should be instrumneted
+    #     despite the enabled instrumentation sampling;
+    # @return [Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
+    #   Format: {
+    #     ok: true,
+    #     result: {
+    #       rel_time: Numeric, # <milliseconds>
+    #       rel_key: String, # lock key
+    #       rel_acq_id: String, # read lock acquirer
+    #       lock_res: Symbol # :released or :nothing_to_release
+    #     }
+    #   }
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def release_read_lock(
+      redis,
+      lock_name,
+      acquirer_id,
+      instrumenter,
+      logger,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
+    )
+      lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+      read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+
+      rel_start_time = clock_gettime
+      # steep:ignore:start
+      fully_release_read_lock(
+        redis, lock_readers_key, read_lock_key, acquirer_id
+      ) => { ok:, result: }
+      # steep:ignore:end
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Symbol]
+
+      time_at = Time.now.to_f
+      rel_end_time = clock_gettime
+      rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
+
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sample_this,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.explicit_read_lock_release', {
+          lock_key: lock_key,
+          acq_id: acquirer_id,
+          lock_res: result[:lock],
+          rel_time: rel_time,
+          at: time_at,
+          instrument: instrument
+        })
+      end if instr_sampled
+
+      {
+        ok: true,
+        result: {
+          rel_time: rel_time,
+          rel_key: lock_key,
+          rel_acq_id: acquirer_id,
+          lock_res: result[:lock]
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # @param redis [RedisClient]
+    # @param lock_readers_key [String]
+    # @param read_lock_key [String]
+    # @param acquirer_id [String]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
+    #   Format: { ok: true, result: { lock: :released/:nothing_to_release } }
+    #
+    # @api private
+    # @since 1.18.0
+    def fully_release_read_lock(redis, lock_readers_key, read_lock_key, acquirer_id)
+      # @type var result: [Integer,Integer]
+      result = redis.with do |rconn|
+        rconn.multi do |transact|
+          transact.call('ZREM', lock_readers_key, acquirer_id)
+          transact.call('DEL', read_lock_key)
+        end
+      end
+
+      { ok: true, result: { lock: (result[0] != 0) ? :released : :nothing_to_release } }
+    end
+  end
+end

data/lib/redis_queued_locks/acquirer.rb

@@ -6,6 +6,7 @@ module RedisQueuedLocks::Acquirer
   require_relative 'acquirer/acquire_lock'
   require_relative 'acquirer/lock_series_poc'
   require_relative 'acquirer/release_lock'
+  require_relative 'acquirer/release_read_lock'
   require_relative 'acquirer/release_all_locks'
   require_relative 'acquirer/release_locks_of'
   require_relative 'acquirer/is_locked'