redis_queued_locks 1.2.0 → 1.3.1

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -6,29 +6,24 @@
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
 # rubocop:disable Metrics/BlockNesting
+# rubocop:disable Style/IfInsideElse
 module RedisQueuedLocks::Acquier::AcquireLock
   require_relative 'acquire_lock/delay_execution'
   require_relative 'acquire_lock/with_acq_timeout'
-  require_relative 'acquire_lock/yield_with_expire'
+  require_relative 'acquire_lock/yield_expire'
   require_relative 'acquire_lock/try_to_lock'
 
   # @since 1.0.0
   extend TryToLock
   # @since 1.0.0
   extend DelayExecution
-  # @since 1.0.0
-  extend YieldWithExpire
+  # @since 1.3.0
+  extend YieldExpire
   # @since 1.0.0
   extend WithAcqTimeout
   # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
-  # @return [Integer] Redis time error (in milliseconds).
-  #
-  # @api private
-  # @since 1.0.0
-  REDIS_TIMESHIFT_ERROR = 2
-
   class << self
     # @param redis [RedisClient]
     #   Redis connection client.
@@ -72,14 +67,25 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #   - Metadata can not contain reserved lock data keys;
     # @option logger [::Logger,#debug]
     #   - Logger object used from the configuration layer (see config[:logger]);
-    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    #   - See `RedisQueuedLocks::Logging::VoidLogger` for example;
+    #   - Supports `SemanticLogger::Logger` (see "semantic_logger" gem)
     # @option log_lock_try [Boolean]
     #   - should be logged the each try of lock acquiring (a lot of logs can be generated depending
     #     on your retry configurations);
     #   - see `config[:log_lock_try]`;
     # @option instrument [NilClass,Any]
-    #    - Custom instrumentation data wich will be passed to the instrumenter's payload
-    #      with :instrument key;
+    #   - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #     with :instrument key;
+    # @option conflict_strategy [Symbol]
+    #   - The conflict strategy mode for cases when the process that obtained the lock
+    #     want to acquire this lock again;
+    #   - By default uses `:wait_for_lock` strategy;
+    #   - pre-confured in `config[:default_conflict_strategy]`;
+    #   - Supports:
+    #     - `:work_through`;
+    #     - `:extendable_work_through`;
+    #     - `:wait_for_lock`;
+    #     - `:dead_locking`;
     # @param [Block]
     #   A block of code that should be executed after the successfully acquired lock.
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -88,6 +94,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #
     # @api private
     # @since 1.0.0
+    # @version 1.3.1
     def acquire_lock(
       redis,
       lock_name,
@@ -110,6 +117,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       instrument:,
       logger:,
       log_lock_try:,
+      conflict_strategy:,
       &block
     )
       # Step 0: Prevent argument type incompatabilities
@@ -124,17 +132,23 @@ module RedisQueuedLocks::Acquier::AcquireLock
       end
 
       # Step 0.2: prevent :meta incompatabiltiies (structure)
-      if meta == ::Hash && (meta.keys.any? do |key|
+      if meta.is_a?(::Hash) && (meta.keys.any? do |key|
         key == 'acq_id' ||
         key == 'ts' ||
         key == 'ini_ttl' ||
         key == 'lock_key' ||
-        key == 'rem_ttl'
+        key == 'rem_ttl' ||
+        key == 'spc_ext_ttl' ||
+        key == 'spc_cnt' ||
+        key == 'l_spc_ext_ini_ttl' ||
+        key == 'l_spc_ext_ts' ||
+        key == 'l_spc_ts'
       end)
         raise(
           RedisQueuedLocks::ArgumentError,
-          '`:meta` keys can not overlap reserved lock data keys' \
-          '"acq_id", "ts", "ini_ttl", "lock_key", "rem_ttl"'
+          '`:meta` keys can not overlap reserved lock data keys ' \
+          '"acq_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"'
         )
       end
 
@@ -223,6 +237,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
             lock_ttl,
             queue_ttl,
             fail_fast,
+            conflict_strategy,
             meta
           ) => { ok:, result: }
 
@@ -235,26 +250,75 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
           # Step 2.1: analyze an acquirement attempt
           if ok
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.lock_obtained] " \
-                "lock_key => '#{result[:lock_key]}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}' " \
-                "acq_time => #{acq_time} (ms)"
+            # Step X: (instrumentation)
+            if acq_process[:result][:process] == :extendable_conflict_work_through
+              # instrumetnation: (reentrant lock with ttl extension)
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.extendable_reentrant_lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
               end
-            end
 
-            # Step X (instrumentation): lock obtained
-            run_non_critical do
-              instrumenter.notify('redis_queued_locks.lock_obtained', {
-                lock_key: result[:lock_key],
-                ttl: result[:ttl],
-                acq_id: result[:acq_id],
-                ts: result[:ts],
-                acq_time: acq_time,
-                instrument:
-              })
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.extendable_reentrant_lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
+            elsif acq_process[:result][:process] == :conflict_work_through
+              # instrumetnation: (reentrant lock without ttl extension)
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.reentrant_lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
+              end
+
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.reentrant_lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
+            else
+              # instrumentation: (classic lock obtain)
+              # NOTE: classic is: acq_process[:result][:process] == :lock_obtaining
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
+              end
+
+              # Step X (instrumentation): lock obtained
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
             end
 
             # Step 2.1.a: successfully acquired => build the result
@@ -262,54 +326,73 @@ module RedisQueuedLocks::Acquier::AcquireLock
               lock_key: result[:lock_key],
               acq_id: result[:acq_id],
               ts: result[:ts],
-              ttl: result[:ttl]
+              ttl: result[:ttl],
+              process: result[:process]
             }
             acq_process[:acquired] = true
             acq_process[:should_try] = false
             acq_process[:acq_time] = acq_time
             acq_process[:acq_end_time] = acq_end_time
-          elsif fail_fast && acq_process[:result] == :fail_fast_no_try
-            acq_process[:should_try] = false
-            if raise_errors
-              raise(
-                RedisQueuedLocks::LockAlreadyObtainedError,
-                "Lock \"#{lock_key}\" is already obtained."
-              )
-            end
           else
-            # Step 2.1.b: failed acquirement => retry
-            acq_process[:tries] += 1
-
-            if (retry_count != nil && acq_process[:tries] >= retry_count) || fail_fast
-              # NOTE:
-              #   - reached the retry limit => quit from the loop
-              #   - should fail fast => quit from the loop
+            # Step 2.2: failed to acquire. anylize each case and act in accordance
+            if acq_process[:result] == :fail_fast_no_try # Step 2.2.a: fail without try
               acq_process[:should_try] = false
-              acq_process[:result] = fail_fast ? :fail_fast_after_try : :retry_limit_reached
-
-              # NOTE:
-              #   - reached the retry limit => dequeue from the lock queue
-              #   - should fail fast => dequeue from the lock queue
-              acq_dequeue.call
 
-              # NOTE: check and raise an error
-              if fail_fast && raise_errors
+              if raise_errors
                 raise(
                   RedisQueuedLocks::LockAlreadyObtainedError,
                   "Lock \"#{lock_key}\" is already obtained."
                 )
-              elsif raise_errors
+              end
+            elsif acq_process[:result] == :conflict_dead_lock # Step 2.2.b: fail after dead lock
+              acq_process[:tries] += 1
+              acq_process[:should_try] = false
+              acq_process[:result] = :conflict_dead_lock
+              acq_dequeue.call
+
+              if raise_errors
                 raise(
-                  RedisQueuedLocks::LockAcquiermentRetryLimitError,
-                  "Failed to acquire the lock \"#{lock_key}\" " \
-                  "for the given retry_count limit (#{retry_count} times)."
+                  RedisQueuedLock::ConflictLockObtainError,
+                  "Lock Conflict: trying to acquire the lock \"#{lock_key}\" " \
+                  "that is already acquired by the current acquier (acq_id: \"#{acquired_id}\")."
                 )
               end
             else
-              # NOTE:
-              #   delay the exceution in order to prevent chaotic lock-acquire attempts
-              #   and to allow other processes and threads to obtain the lock too.
-              delay_execution(retry_delay, retry_jitter)
+              acq_process[:tries] += 1 # Step RETRY: possible retry case
+
+              if fail_fast # Step RETRY.A: fail after try
+                acq_process[:should_try] = false
+                acq_process[:result] = :fail_fast_after_try
+                acq_dequeue.call
+
+                if raise_errors
+                  raise(
+                    RedisQueuedLocks::LockAlreadyObtainedError,
+                    "Lock \"#{lock_key}\" is already obtained."
+                  )
+                end
+              else
+                # Step RETRY.B: fail cuz the retry count is reached
+                if retry_count != nil && acq_process[:tries] >= retry_count
+                  acq_process[:should_try] = false
+                  acq_process[:result] = :retry_limit_reached
+                  acq_dequeue.call
+
+                  if raise_errors
+                    raise(
+                      RedisQueuedLocks::LockAcquiermentRetryLimitError,
+                      "Failed to acquire the lock \"#{lock_key}\" " \
+                      "for the given retry_count limit (#{retry_count} times)."
+                    )
+                  end
+                else
+                  # Step RETRY.X: no significant failures => retry easily :)
+                  # NOTE:
+                  #   delay the exceution in order to prevent chaotic lock-acquire attempts
+                  #   and to allow other processes and threads to obtain the lock too.
+                  delay_execution(retry_delay, retry_jitter)
+                end
+              end
             end
           end
         end
@@ -323,10 +406,18 @@ module RedisQueuedLocks::Acquier::AcquireLock
             yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
             ttl_shift = (
-              (yield_time - acq_process[:acq_end_time]) * 1000 - REDIS_TIMESHIFT_ERROR
+              (yield_time - acq_process[:acq_end_time]) * 1000 -
+              RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
             ).ceil(2)
 
-            yield_with_expire(
+            should_expire =
+              acq_process[:result][:process] != :extendable_conflict_work_through &&
+              acq_process[:result][:process] != :conflict_work_through
+
+            should_decrease =
+              acq_process[:result][:process] == :extendable_conflict_work_through
+
+            yield_expire(
               redis,
               logger,
               lock_key,
@@ -335,6 +426,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
               ttl_shift,
               ttl,
               queue_ttl,
+              should_expire, # NOTE: should expire the lock after the block execution
+              should_decrease, # NOTE: should decrease the lock ttl in reentrant locks?
               &block
             )
           ensure
@@ -343,17 +436,33 @@ module RedisQueuedLocks::Acquier::AcquireLock
               (acq_process[:rel_time] - acq_process[:acq_end_time]) * 1000
             ).ceil(2)
 
-            # Step X (instrumentation): lock_hold_and_release
-            run_non_critical do
-              instrumenter.notify('redis_queued_locks.lock_hold_and_release', {
-                hold_time: acq_process[:hold_time],
-                ttl: acq_process[:lock_info][:ttl],
-                acq_id: acq_process[:lock_info][:acq_id],
-                ts: acq_process[:lock_info][:ts],
-                lock_key: acq_process[:lock_info][:lock_key],
-                acq_time: acq_process[:acq_time],
-                instrument:
-              })
+            if acq_process[:result][:process] == :extendable_conflict_work_through ||
+               acq_process[:result][:process] == :conflict_work_through
+              # Step X (instrumentation): reentrant_lock_hold_completes
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.reentrant_lock_hold_completes', {
+                  hold_time: acq_process[:hold_time],
+                  ttl: acq_process[:lock_info][:ttl],
+                  acq_id: acq_process[:lock_info][:acq_id],
+                  ts: acq_process[:lock_info][:ts],
+                  lock_key: acq_process[:lock_info][:lock_key],
+                  acq_time: acq_process[:acq_time],
+                  instrument:
+                })
+              end
+            else
+              # Step X (instrumentation): lock_hold_and_release
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.lock_hold_and_release', {
+                  hold_time: acq_process[:hold_time],
+                  ttl: acq_process[:lock_info][:ttl],
+                  acq_id: acq_process[:lock_info][:acq_id],
+                  ts: acq_process[:lock_info][:ts],
+                  lock_key: acq_process[:lock_info][:lock_key],
+                  acq_time: acq_process[:acq_time],
+                  instrument:
+                })
+              end
             end
           end
         else
@@ -362,11 +471,12 @@ module RedisQueuedLocks::Acquier::AcquireLock
       else
         if acq_process[:result] != :retry_limit_reached &&
            acq_process[:result] != :fail_fast_no_try &&
-           acq_process[:result] != :fail_fast_after_try
-          # NOTE: we have only two situations if lock is not acquired withou fast-fail flag:
-          #   - time limit is reached
-          #   - retry count limit is reached
-          #   In other cases the lock obtaining time and tries count are infinite.
+           acq_process[:result] != :fail_fast_after_try &&
+           acq_process[:result] != :conflict_dead_lock
+          # NOTE: we have only two situations if lock is not acquired without explicit failures:
+          #   - time limit is reached;
+          #   - retry count limit is reached;
+          #   - **(notice: in other cases the lock obtaining time and tries count are infinite)
           acq_process[:result] = :timeout_reached
         end
         # Step 3.b: lock is not acquired (acquier is dequeued by timeout callback)
@@ -379,3 +489,4 @@ end
 # rubocop:enable Metrics/MethodLength
 # rubocop:enable Metrics/ClassLength
 # rubocop:enable Metrics/BlockNesting
+# rubocop:enable Style/IfInsideElse

data/lib/redis_queued_locks/acquier/lock_info.rb

@@ -12,12 +12,20 @@ module RedisQueuedLocks::Acquier::LockInfo
     #     'lock_key' => "rql:lock:your_lockname", # acquired lock key
     #     'acq_id' => "rql:acq:process_id/thread_id", # lock acquier identifier
     #     'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
-    #     'ini_ttl' => 123456789, # initial lock key ttl (milliseconds),
+    #     'ini_ttl' => 123456789, # initial lock key ttl (milliseconds)
     #     'rem_ttl' => 123456789, # remaining lock key ttl (milliseconds)
+    #     <additional keys for reentrant locks>:
+    #     'spc_cnt' => 2, # lock reentreing count (if lock was used as reentrant lock)
+    #     'l_spc_ts' => 123456.1234 # (epoch) <non-extendable reentrant lock obtained at> timestamp
+    #     'spc_ext_ttl' => 14500, # (milliseconds) the sum of all ttl extensions
+    #     '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
     #   }
     #
     # @api private
     # @since 1.0.0
+    # @version 1.3.0
+    # rubocop:disable Metrics/MethodLength
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 
@@ -48,9 +56,17 @@ module RedisQueuedLocks::Acquier::LockInfo
             lock_data['ts'] = Float(lock_data['ts'])
             lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
             lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+            lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
+            lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
+            lock_data['spc_ext_ttl'] = Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
+            lock_data['l_spc_ext_ini_ttl'] =
+              Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
+            lock_data['l_spc_ext_ts'] =
+              Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
           end
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquier/locks.rb

@@ -45,6 +45,7 @@ module RedisQueuedLocks::Acquier::Locks
     #
     # @api private
     # @since 1.0.0
+    # @version 1.3.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
       # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
@@ -72,6 +73,14 @@ module RedisQueuedLocks::Acquier::Locks
                   lock_data['ts'] = Float(lock_data['ts'])
                   lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
                   lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+                  lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
+                  lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
+                  lock_data['spc_ext_ttl'] =
+                    Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
+                  lock_data['l_spc_ext_ini_ttl'] =
+                    Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
+                  lock_data['l_spc_ext_ts'] =
+                    Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
                 end
               end
             end

data/lib/redis_queued_locks/client.rb

@@ -22,6 +22,7 @@ class RedisQueuedLocks::Client
     setting :log_lock_try, false
     setting :dead_request_ttl, (1 * 24 * 60 * 60 * 1000) # NOTE: 1 day in milliseconds
     setting :is_timed_by_default, false
+    setting :default_conflict_strategy, :wait_for_lock
 
     validate('retry_count') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
     validate('retry_delay') { |val| val.is_a?(::Integer) && val >= 0 }
@@ -36,6 +37,14 @@ class RedisQueuedLocks::Client
     validate('log_lock_try', :boolean)
     validate('dead_request_ttl') { |val| val.is_a?(::Integer) && val > 0 }
     validate('is_timed_by_default', :boolean)
+    validate('default_conflict_strategy') do |val|
+      # rubocop:disable Layout/MultilineOperationIndentation
+      val == :work_through ||
+      val == :extendable_work_through ||
+      val == :wait_for_lock ||
+      val == :dead_locking
+      # rubocop:enable Layout/MultilineOperationIndentation
+    end
   end
 
   # @return [RedisClient]
@@ -96,19 +105,31 @@ class RedisQueuedLocks::Client
   #   already obtained;
   #   - Should the logic exit immidietly after the first try if the lock was obtained
   #   by another process while the lock request queue was initially empty;
+  # @option conflict_strategy [Symbol]
+  #   - The conflict strategy mode for cases when the process that obtained the lock
+  #     want to acquire this lock again;
+  #   - By default uses `:wait_for_lock` strategy;
+  #   - pre-confured in `config[:default_conflict_strategy]`;
+  #   - Supports:
+  #     - `:work_through` - continue working under the lock without lock's TTL extension;
+  #     - `:extendable_work_through` - continue working under the lock with lock's TTL extension;
+  #     - `:wait_for_lock` - (default) - work in classic way
+  #       (with timeouts, retry delays, retry limits, etc - in classic way :));
+  #     - `:dead_locking` - fail with deadlock exception;
   # @option meta [NilClass,Hash<String|Symbol,Any>]
   #   - A custom metadata wich will be passed to the lock data in addition to the existing data;
   #   - Metadata can not contain reserved lock data keys;
   # @option logger [::Logger,#debug]
   #   - Logger object used from the configuration layer (see config[:logger]);
   #   - See `RedisQueuedLocks::Logging::VoidLogger` for example;
+  #   - Supports `SemanticLogger::Logger` (see "semantic_logger" gem)
   # @option log_lock_try [Boolean]
   #   - should be logged the each try of lock acquiring (a lot of logs can
   #     be generated depending on your retry configurations);
   #   - see `config[:log_lock_try]`;
   # @option instrument [NilClass,Any]
-  #    - Custom instrumentation data wich will be passed to the instrumenter's payload
-  #      with :instrument key;
+  #   - Custom instrumentation data wich will be passed to the instrumenter's payload
+  #     with :instrument key;
   # @param block [Block]
   #   A block of code that should be executed after the successfully acquired lock.
   # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -117,6 +138,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
+  # @version 1.3.0
   def lock(
     lock_name,
     ttl: config[:default_lock_ttl],
@@ -128,6 +150,7 @@ class RedisQueuedLocks::Client
     retry_jitter: config[:retry_jitter],
     raise_errors: false,
     fail_fast: false,
+    conflict_strategy: config[:default_conflict_strategy],
     identity: uniq_identity,
     meta: nil,
     logger: config[:logger],
@@ -153,6 +176,7 @@ class RedisQueuedLocks::Client
       instrumenter: config[:instrumenter],
       identity:,
       fail_fast:,
+      conflict_strategy:,
       meta:,
       logger: config[:logger],
       log_lock_try: config[:log_lock_try],
@@ -165,6 +189,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
+  # @version 1.3.0
   def lock!(
     lock_name,
     ttl: config[:default_lock_ttl],
@@ -175,6 +200,7 @@ class RedisQueuedLocks::Client
     retry_delay: config[:retry_delay],
     retry_jitter: config[:retry_jitter],
     fail_fast: false,
+    conflict_strategy: config[:default_conflict_strategy],
     identity: uniq_identity,
     meta: nil,
     logger: config[:logger],
@@ -198,6 +224,7 @@ class RedisQueuedLocks::Client
       log_lock_try:,
       meta:,
       instrument:,
+      conflict_strategy:,
       &block
     )
   end

data/lib/redis_queued_locks/errors.rb

@@ -24,4 +24,8 @@ module RedisQueuedLocks
   # @api pulic
   # @since 1.0.0
   TimedLockTimeoutError = Class.new(Error)
+
+  # @api public
+  # @since 1.3.0
+  ConflictLockObtainError = Class.new(Error)
 end

data/lib/redis_queued_locks/logging.rb

@@ -16,7 +16,7 @@ module RedisQueuedLocks::Logging
       return true if logger.is_a?(::Logger)
 
       # NOTE:
-      #   - convinient/conventional way to support the popular`semantic_logger` library
+      #   - convinient/conventional way to support the popular `semantic_logger` library
       #   - see https://logger.rocketjob.io/
       #   - see https://github.com/reidmorrison/semantic_logger
       return true if defined?(::SemanticLogger::Logger) && logger.is_a?(::SemanticLogger::Logger)

data/lib/redis_queued_locks/resource.rb

@@ -21,6 +21,12 @@ module RedisQueuedLocks::Resource
   # @since 1.0.0
   LOCK_QUEUE_PATTERN = 'rql:lock_queue:*'
 
+  # @return [Integer] Redis time error (in milliseconds).
+  #
+  # @api private
+  # @since 1.3.0
+  REDIS_TIMESHIFT_ERROR = 2
+
   class << self
     # Returns 16-byte unique identifier. It is used for uniquely
     # identify current process between different nodes/pods of your application

data/lib/redis_queued_locks/version.rb

@@ -5,6 +5,6 @@ module RedisQueuedLocks
   #
   # @api public
   # @since 0.0.1
-  # @version 1.2.0
-  VERSION = '1.2.0'
+  # @version 1.3.1
+  VERSION = '1.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-27 00:00:00.000000000 Z
+date: 2024-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -60,7 +60,7 @@ files:
 - lib/redis_queued_locks/acquier/acquire_lock/delay_execution.rb
 - lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb
 - lib/redis_queued_locks/acquier/acquire_lock/with_acq_timeout.rb
-- lib/redis_queued_locks/acquier/acquire_lock/yield_with_expire.rb
+- lib/redis_queued_locks/acquier/acquire_lock/yield_expire.rb
 - lib/redis_queued_locks/acquier/clear_dead_requests.rb
 - lib/redis_queued_locks/acquier/extend_lock_ttl.rb
 - lib/redis_queued_locks/acquier/is_locked.rb