redis_queued_locks 0.0.20 → 0.0.21

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module RedisQueuedLocks::Acquier::ReleaseAllLocks
+  # @since 0.1.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # 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;
+    #
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param batch_size [Integer]
+    #   The number of lock keys that should be released in a time.
+    # @param isntrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
+    #   Format: { ok: true/false, result: Hash<Symbol,Numeric> }
+    #
+    # @api private
+    # @since 0.1.0
+    def release_all_locks(redis, batch_size, instrumenter)
+      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      fully_release_all_locks(redis, batch_size) => { ok:, result: }
+      time_at = Time.now.to_i
+      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      rel_time = ((rel_end_time - rel_start_time) * 1_000).ceil(2)
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.explicit_all_locks_release', {
+          at: time_at,
+          rel_time: rel_time,
+          rel_keys: result[:rel_keys]
+        })
+      end
+
+      RedisQueuedLocks::Data[
+        ok: true,
+        result: { rel_key_cnt: result[:rel_keys], rel_time: rel_time }
+      ]
+    end
+
+    private
+
+    # Release all locks: clear all lock queus and expire all locks.
+    #
+    # @param redis [RedisClient]
+    # @param batch_size [Integer]
+    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
+    #
+    # @api private
+    # @since 0.1.0
+    def fully_release_all_locks(redis, batch_size)
+      result = redis.pipelined do |pipeline|
+        # Step A: release all queus and their related locks
+        redis.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+          count: batch_size
+        ) do |lock_queue|
+          # TODO: reduce unnecessary iterations
+          pipeline.call('ZREMRANGEBYSCORE', lock_queue, '-inf', '+inf')
+          pipeline.call('EXPIRE', RedisQueuedLocks::Resource.lock_key_from_queue(lock_queue), '0')
+        end
+
+        # Step B: release all locks
+        redis.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_PATTERN,
+          count: batch_size
+        ) do |lock_key|
+          # TODO: reduce unnecessary iterations
+          pipeline.call('EXPIRE', lock_key, '0')
+        end
+      end
+
+      rel_keys = result.count { |red_res| red_res == 0 }
+
+      RedisQueuedLocks::Data[ok: true, result: { rel_keys: rel_keys }]
+    end
+  end
+end

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module RedisQueuedLocks::Acquier::ReleaseLock
+  # @since 0.1.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # Release the concrete lock:
+    # - 1. clear lock queue: al; related processes released
+    #      from the lock aquierment and should retry;
+    # - 2. delete the lock: drop lock key from Redis;
+    # It is safe because the lock obtain logic is transactional and
+    # watches the original lock for changes.
+    #
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param lock_name [String]
+    #   The lock name that should be released.
+    # @param isntrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
+    #   Format: { ok: true/false, result: Hash<Symbil,Numeric|String> }
+    #
+    # @api private
+    # @since 0.1.0
+    def release_lock(redis, lock_name, instrumenter)
+      lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+      lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+
+      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: }
+      time_at = Time.now.to_i
+      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      rel_time = ((rel_end_time - rel_start_time) * 1_000).ceil(2)
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.explicit_lock_release', {
+          lock_key: lock_key,
+          lock_key_queue: lock_key_queue,
+          rel_time: rel_time,
+          at: time_at
+        })
+      end
+
+      RedisQueuedLocks::Data[
+        ok: true,
+        result: { rel_time: rel_time, rel_key: lock_key, rel_queue: lock_key_queue }
+      ]
+    end
+
+    private
+
+    # Realease the lock: clear the lock queue and expire the lock.
+    #
+    # @param redis [RedisClient]
+    # @param lock_key [String]
+    # @param lock_key_queue [String]
+    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
+    #
+    # @api private
+    # @since 0.1.0
+    def fully_release_lock(redis, lock_key, lock_key_queue)
+      result = redis.multi do |transact|
+        transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
+        transact.call('EXPIRE', lock_key, '0')
+      end
+
+      RedisQueuedLocks::Data[ok: true, result:]
+    end
+  end
+end