redis_queued_locks 0.0.29 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3137184f5a89b895fe347d8080957e08a57974e91d5a68189d0eb157afd7c3eb
-  data.tar.gz: 7b059f5de5cde2af1634eed3aeae540afd7edfc5ba564781789649098e53e0a1
+  metadata.gz: '0920957ed856cf515d2867ecd6ed7b1911ba53466822f09d5bd98386a5be4296'
+  data.tar.gz: 587fa64039e85a633fc2c65d5c0b012d7bfb29b9ccd25177e0895deb33850c38
 SHA512:
-  metadata.gz: 4821b6c0fc142d90fae314aa11c92069be9223cc4a61be077ff6e19278fae97f920d31b590c5688f3614159a2f5c9d9d1792d8a6aee50f51d7b24f83ea1a9298
-  data.tar.gz: 80a0de485f263459c52d230cc0e604d0c742db235a6a9b57053cc84001e9e146cfc35b9c31aff5e1ef5a2796692559f95fe94db39350720277fb219ef95a2685
+  metadata.gz: 388e0d43c66464672bbe019dc0f26e3bac44be0cc3e5dcdb502ccd9b2d0b82931de2608c6b7219b2c190b9024197a0cbf1263a7cc7d4f8ed6568480ce6120930
+  data.tar.gz: 56158aca2424c21fc3fcbeebbd33625559aceca82143c2e18700334c6485e919d4005f4391ba3a07b0839e9122f57b9c5d223ebfd4bc38bdd4f61b58bc94f34f

data/CHANGELOG.md

@@ -1,8 +1,19 @@
 ## [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: more detailed logs to `RedisQueuedLocks::Acquier::AcquireLock::TryToLock`;
+- Logging: added more detailed logs to `RedisQueuedLocks::Acquier::AcquireLock::TryToLock`;
 
 ## [0.0.28] - 2024-03-21
 ### Added

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

@@ -43,23 +43,26 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
         logger.debug(
           "[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] " \
             "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')
@@ -74,6 +77,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               logger.debug(
                 "[redis_queued_locks.try_lock.acq_added_to_queue] " \
                 "lock_key => '#{lock_key}' " \
+                "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}'"
               )
             end
@@ -96,6 +100,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               logger.debug(
                 "[redis_queued_locks.try_lock.remove_expired_acqs] " \
                 "lock_key => '#{lock_key}' " \
+                "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}'"
               )
             end
@@ -113,6 +118,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               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}'"
               )
@@ -124,8 +130,28 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             "[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
@@ -133,6 +159,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
                 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}'"
                 )
@@ -167,6 +194,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
                   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}'"
@@ -213,6 +241,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
                   logger.debug(
                     "[redis_queued_locks.try_lock.run__free_to_acquire] " \
                     "lock_key => '#{lock_key}' " \
+                    "queue_ttl => #{queue_ttl} " \
                     "acq_id => '#{acquier_id}'"
                   )
                 end
@@ -229,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]

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.29
-  VERSION = '0.0.29'
+  # @version 0.0.30
+  VERSION = '0.0.30'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -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.