redis_queued_locks 0.0.28 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de2915b0828a1c82327dd301b41388cc649b2b922ca18f98cde7e8607753b28
-  data.tar.gz: da86f22a9ed5a834467ae80d9596c9efb0be1e645546c5b32a8f5d5b1dcec294
+  metadata.gz: '0920957ed856cf515d2867ecd6ed7b1911ba53466822f09d5bd98386a5be4296'
+  data.tar.gz: 587fa64039e85a633fc2c65d5c0b012d7bfb29b9ccd25177e0895deb33850c38
 SHA512:
-  metadata.gz: 1f3a60c00b200f9e474ad0471e8e59541786f6e035df4c4d93d553eb93456fc99f0743970d3154fa8d3878a4e67b03d8d2ae2c16b71336b8d277f886dd4821e4
-  data.tar.gz: 1b52f00d36d568dce68b14caa0cbfb0e1ec793a7eec9adeb5bbca3c042b8bd224cec5f74488c4f0b34de0b302ec98392584a07e21bd02f106a370f3341ef3a35
+  metadata.gz: 388e0d43c66464672bbe019dc0f26e3bac44be0cc3e5dcdb502ccd9b2d0b82931de2608c6b7219b2c190b9024197a0cbf1263a7cc7d4f8ed6568480ce6120930
+  data.tar.gz: 56158aca2424c21fc3fcbeebbd33625559aceca82143c2e18700334c6485e919d4005f4391ba3a07b0839e9122f57b9c5d223ebfd4bc38bdd4f61b58bc94f34f

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.0.30] - 2024-03-23
+### Fixed
+- Re-enqueue problem: fixed a problem when the expired lock requests were infinitly re-added to the lock queue
+  and immediately removed from the lock queue rather than being re-positioned. It happens when the lock request
+  ttl reached the queue ttl, and the new request now had the dead score forever (fix: it's score now will be correctly
+  recalculated from the current time at the dead score time moment);
+### Added
+- Logging: more detailed logs to the `RedisQueuedLocks::Acquier::AcquierLock` logic and it's sub-modules:
+  - added new logs;
+  - added `queue_ttl` to each log;
+
+## [0.0.29] - 2024-03-23
+### Added
+- Logging: added more detailed logs to `RedisQueuedLocks::Acquier::AcquireLock::TryToLock`;
+
 ## [0.0.28] - 2024-03-21
 ### Added
 - Logging: added `acq_id` to every log message;

data/README.md

@@ -600,23 +600,21 @@ Detalized event semantics and payload structure:
 
 ## Roadmap
 
-- **Major**
-  - Semantic Error objects for unexpected Redis errors;
-  - `100%` test coverage;
-  - per-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
-    the acquired lock for long-running blocks of code (that invoked "under" the lock
-    whose ttl may expire before the block execution completes);
-  - an ability to add custom metadata to the lock and an ability to read this data;
-  - lock prioritization;
-  - support for LIFO strategy;
-  - structured logging;
-- **Minor**
-  - GitHub Actions CI;
-  - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
-  - better code stylization and interesting refactorings;
-  - lock queue expiration (dead queue cleanup);
-  - support for `Dragonfly` DB backend;
-  - support for `Garnet` DB backend;
+- Semantic Error objects for unexpected Redis errors;
+- `100%` test coverage;
+- per-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
+  the acquired lock for long-running blocks of code (that invoked "under" the lock
+  whose ttl may expire before the block execution completes);
+- an ability to add custom metadata to the lock and an ability to read this data;
+- lock prioritization;
+- support for LIFO strategy;
+- structured logging;
+- GitHub Actions CI;
+- `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
+- better code stylization and interesting refactorings;
+- dead queue cleanup;
+- support for `Dragonfly` DB backend;
+- support for `Garnet` DB backend;
 
 ---
 

data/lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 0.1.0
-# rubocop:disable Metrics/ModuleLength
+# rubocop:disable Metrics/ModuleLength, Metrics/BlockNesting
 module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @since 0.1.0
   extend RedisQueuedLocks::Utilities
@@ -41,25 +41,28 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     if log_lock_try
       run_non_critical do
         logger.debug(
-          "[redis_queued_locks.try_lock_start] " \
+          "[redis_queued_locks.try_lock.start] " \
           "lock_key => '#{lock_key}' " \
-          "acq_id => '#{acquier_id}'"
+          "queue_ttl => #{queue_ttl} " \
+          "acq_id => '#{acquier_id}' "
         )
       end
     end
 
-    # Step 0: watch the lock key changes (and discard acquirement if lock is already acquired)
+    # Step X: start to work with lock acquiring
     result = redis.with do |rconn|
       if log_lock_try
         run_non_critical do
           logger.debug(
-            "[redis_queued_locks.try_lock_rconn_fetched] " \
+            "[redis_queued_locks.try_lock.rconn_fetched] " \
             "lock_key => '#{lock_key}' " \
+            "queue_ttl => #{queue_ttl} " \
             "acq_id => '#{acquier_id}'"
           )
         end
       end
 
+      # Step 0: watch the lock key changes (and discard acquirement if lock is already acquired)
       rconn.multi(watch: [lock_key]) do |transact|
         # Fast-Step X0: fail-fast check
         if fail_fast && rconn.call('HGET', lock_key, 'acq_id')
@@ -69,6 +72,17 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step 1: add an acquier to the lock acquirement queue
           res = rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
 
+          if log_lock_try
+            run_non_critical do
+              logger.debug(
+                "[redis_queued_locks.try_lock.acq_added_to_queue] " \
+                "lock_key => '#{lock_key}' " \
+                "queue_ttl => #{queue_ttl} " \
+                "acq_id => '#{acquier_id}'"
+              )
+            end
+          end
+
           RedisQueuedLocks.debug(
             "Step №1: добавление в очередь (#{acquier_id}). [ZADD to the queue: #{res}]"
           )
@@ -81,6 +95,17 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
           )
 
+          if log_lock_try
+            run_non_critical do
+              logger.debug(
+                "[redis_queued_locks.try_lock.remove_expired_acqs] " \
+                "lock_key => '#{lock_key}' " \
+                "queue_ttl => #{queue_ttl} " \
+                "acq_id => '#{acquier_id}'"
+              )
+            end
+          end
+
           RedisQueuedLocks.debug(
             "Step №2: дропаем из очереди просроченных ожидающих. [ZREMRANGE: #{res}]"
           )
@@ -88,15 +113,59 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step 3: get the actual acquier waiting in the queue
           waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
+          if log_lock_try
+            run_non_critical do
+              logger.debug(
+                "[redis_queued_locks.try_lock.get_first_from_queue] " \
+                "lock_key => '#{lock_key}' " \
+                "queue_ttl => #{queue_ttl} " \
+                "acq_id => '#{acquier_id}' " \
+                "first_acq_id_in_queue => '#{waiting_acquier}'"
+              )
+            end
+          end
+
           RedisQueuedLocks.debug(
             "Step №3: какой процесс в очереди сейчас ждет. " \
             "[ZRANGE <следующий процесс>: #{waiting_acquier} :: <текущий процесс>: #{acquier_id}]"
           )
 
+          # Step PRE-4.x: check if the request time limit is reached
+          #   (when the current try self-removes itself from queue (queue ttl has come))
+          if waiting_acquier == nil
+            if log_lock_try
+              run_non_critical do
+                logger.debug(
+                  "[redis_queued_locks.try_lock.exit__queue_ttl_reached] " \
+                  "lock_key => '#{lock_key}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}'"
+                )
+              end
+            end
+
+            RedisQueuedLocks.debug(
+              "Step PRE-ROLLBACK №0: достигли лимита времени эквайра лока (queue ttl). выходим. " \
+              "[Наша позиция: #{acquier_id}. queue_ttl: #{queue_ttl}]"
+            )
+
+            inter_result = :dead_score_reached
           # Step 4: check the actual acquier: is it ours? are we aready to lock?
-          unless waiting_acquier == acquier_id
+          elsif waiting_acquier != acquier_id
             # Step ROLLBACK 1.1: our time hasn't come yet. retry!
 
+            if log_lock_try
+              run_non_critical do
+                logger.debug(
+                  "[redis_queued_locks.try_lock.exit__no_first] " \
+                  "lock_key => '#{lock_key}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "first_acq_id_in_queue => '#{waiting_acquier}'"
+                )
+              end
+            end
+
             RedisQueuedLocks.debug(
               "Step ROLLBACK №1: не одинаковые ключи. выходим. " \
               "[Ждет: #{waiting_acquier}. А нужен: #{acquier_id}]"
@@ -120,6 +189,19 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             if locked_by_acquier
               # Step ROLLBACK 2: required lock is stil acquired. retry!
 
+              if log_lock_try
+                run_non_critical do
+                  logger.debug(
+                    "[redis_queued_locks.try_lock.exit__still_obtained] " \
+                    "lock_key => '#{lock_key}' " \
+                    "queue_ttl => #{queue_ttl} " \
+                    "acq_id => '#{acquier_id}' " \
+                    "first_acq_id_in_queue => '#{waiting_acquier}' " \
+                    "locked_by_acq_id => '#{locked_by_acquier}'"
+                  )
+                end
+              end
+
               RedisQueuedLocks.debug(
                 "Step ROLLBACK №2: Ключ уже занят. Ничего не делаем. " \
                 "[Занят процессом: #{locked_by_acquier}]"
@@ -153,6 +235,17 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
               # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
               transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
+
+              if log_lock_try
+                run_non_critical do
+                  logger.debug(
+                    "[redis_queued_locks.try_lock.run__free_to_acquire] " \
+                    "lock_key => '#{lock_key}' " \
+                    "queue_ttl => #{queue_ttl} " \
+                    "acq_id => '#{acquier_id}'"
+                  )
+                end
+              end
             end
           end
         end
@@ -165,6 +258,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     when fail_fast && inter_result == :fail_fast_no_try
       # Step 7.a: lock is still acquired and we should exit from the logic as soon as possible
       RedisQueuedLocks::Data[ok: false, result: inter_result]
+    when inter_result == :dead_score_reached
+      RedisQueuedLocks::Data[ok: false, result: inter_result]
     when inter_result == :lock_is_still_acquired || inter_result == :acquier_is_not_first_in_queue
       # Step 7.b: lock is still acquired by another process => failed to acquire
       RedisQueuedLocks::Data[ok: false, result: inter_result]
@@ -210,4 +305,4 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     RedisQueuedLocks::Data[ok: true, result: result]
   end
 end
-# rubocop:enable Metrics/ModuleLength
+# rubocop:enable Metrics/ModuleLength, Metrics/BlockNesting

data/lib/redis_queued_locks/acquier/acquire_lock/yield_with_expire.rb

@@ -13,12 +13,23 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
   # @param timed [Boolean] Should the lock be wrapped by Tiemlout with with lock's ttl
   # @param ttl_shift [Float] Lock's TTL shifting. Should affect block's ttl. In millisecodns.
   # @param ttl [Integer,NilClass] Lock's time to live (in ms). Nil means "without timeout".
+  # @param queue_ttl [Integer] Lock request lifetime.
   # @param block [Block] Custom logic that should be invoked unter the obtained lock.
   # @return [Any,NilClass] nil is returned no block parametr is provided.
   #
   # @api private
   # @since 0.1.0
-  def yield_with_expire(redis, logger, lock_key, acquier_id, timed, ttl_shift, ttl, &block)
+  def yield_with_expire(
+    redis,
+    logger,
+    lock_key,
+    acquier_id,
+    timed,
+    ttl_shift,
+    ttl,
+    queue_ttl,
+    &block
+  )
     if block_given?
       if timed && ttl != nil
         timeout = ((ttl - ttl_shift) / 1000.0).yield_self { |time| (time < 0) ? 0.0 : time }
@@ -32,6 +43,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
       logger.debug(
         "[redis_queued_locks.expire_lock] " \
         "lock_key => '#{lock_key}' " \
+        "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquier_id}'"
       )
     end

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -140,6 +140,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
         logger.debug(
           "[redis_queued_locks.start_lock_obtaining] " \
           "lock_key => '#{lock_key}' " \
+          "queue_ttl => #{queue_ttl} " \
           "acq_id => '#{acquier_id}'"
         )
       end
@@ -150,6 +151,30 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
         # Step 2.1: caclically try to obtain the lock
         while acq_process[:should_try]
+          run_non_critical do
+            logger.debug(
+              "[redis_queued_locks.start_try_to_lock_cycle] " \
+              "lock_key => '#{lock_key}' " \
+              "queue_ttl => #{queue_ttl} " \
+              "acq_id => '{#{acquier_id}'"
+            )
+          end
+
+          # Step 2.X: check the actual score: is it in queue ttl limit or not?
+          if RedisQueuedLocks::Resource.dead_score_reached?(acquier_position, queue_ttl)
+            # Step 2.X.X: dead score reached => re-queue the lock request with the new score;
+            acquier_position = RedisQueuedLocks::Resource.calc_initial_acquier_position
+
+            run_non_critical do
+              logger.debug(
+                "[redis_queued_locks.dead_score_reached__reset_acquier_position] " \
+                "lock_key => '#{lock_key} " \
+                "queue_ttl => #{queue_ttl} " \
+                "acq_id => '#{acquier_id}'"
+              )
+            end
+          end
+
           try_to_lock(
             redis,
             logger,
@@ -176,6 +201,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
               logger.debug(
                 "[redis_queued_locks.lock_obtained] " \
                 "lock_key => '#{result[:lock_key]}' " \
+                "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}' " \
                 "acq_time => #{acq_time} (ms)"
               )
@@ -240,7 +266,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
               end
             else
               # NOTE:
-              #   delay the exceution in order to prevent chaotic attempts
+              #   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
@@ -255,7 +281,17 @@ module RedisQueuedLocks::Acquier::AcquireLock
           begin
             yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             ttl_shift = ((yield_time - acq_process[:acq_end_time]) * 1000).ceil(2)
-            yield_with_expire(redis, logger, lock_key, acquier_id, timed, ttl_shift, ttl, &block)
+            yield_with_expire(
+              redis,
+              logger,
+              lock_key,
+              acquier_id,
+              timed,
+              ttl_shift,
+              ttl,
+              queue_ttl,
+              &block
+            )
           ensure
             acq_process[:rel_time] = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             acq_process[:hold_time] = (

data/lib/redis_queued_locks/resource.rb

@@ -82,6 +82,20 @@ module RedisQueuedLocks::Resource
       Time.now.to_f - queue_ttl
     end
 
+    # @param acquier_position [Float]
+    #   A time (epoch, seconds.microseconds) that represents
+    #   the acquier position in lock request queue.
+    # @parma queue_ttl [Integer]
+    #   In second.
+    # @return [Boolean]
+    #   Is the lock request time limit has reached or not.
+    #
+    # @api private
+    # @since 0.1.0
+    def dead_score_reached?(acquier_position, queue_ttl)
+      (acquier_position + queue_ttl) < Time.now.to_f
+    end
+
     # @param lock_queue [String]
     # @return [String]
     #

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.30
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-21 00:00:00.000000000 Z
+date: 2024-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Queued distributed locks based on Redis.