redis_queued_locks 1.19.0 → 1.20.0

data/sig/redis_queued_locks/acquirer/locks.rbs

@@ -9,16 +9,25 @@ module RedisQueuedLocks
       type locksInfo = Set[{ lock: String, status: Symbol, info: lockInfo }]
       type locks = lockList | locksInfo
 
-      def self.locks: (RC::client redis_client, scan_size: Integer, with_info: bool) -> locks
+      LOCK_STATE_REPLIES: Integer
+
+      def self.locks: (
+        RC::client redis_client,
+        scan_size: Integer,
+        with_info: bool,
+        lock_index_enabled: bool
+      ) -> locks
 
       private def self.scan_locks: (RC::client redis_client, Integer scan_size) -> lockList
-      private def self.extract_locks_info: (RC::client redis_client, Set[::String] lock_keys) -> locksInfo
+      private def self.index_locks: (RC::client redis_client, Integer scan_size) -> lockList
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
+      private def self.extract_locks_info: (RC::client redis_client, Set[::String] lock_keys, Integer scan_size) -> locksInfo
       private def self.read_lock_info: (
-        RC::client redis_client,
-        String lock_name,
         String lock_key,
-        Array[String] redis_time,
-        Array[[String, Float]] read_locks
+        Integer now,
+        Array[[String, Float]] live_read_locks,
+        Array[Hash[String,String]] read_locks_data,
+        Integer read_locks_data_at
       ) -> lockInfo?
     end
   end

data/sig/redis_queued_locks/acquirer/queues.rbs

@@ -7,10 +7,17 @@ module RedisQueuedLocks
       type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,String|Float]] }]
       type queues = queueList | queuesInfo
 
-      def self.queues: (RC::client redis_client, scan_size: Integer, with_info: bool) -> queues
+      def self.queues: (
+        RC::client redis_client,
+        scan_size: Integer,
+        with_info: bool,
+        lock_index_enabled: bool
+      ) -> queues
 
       private def self.scan_queues: (RC::client redis_client, Integer scan_size) -> queueList
-      private def self.extract_queues_info: (RC::client redis_client, Set[String] lock_queues) -> queuesInfo
+      private def self.index_queues: (RC::client redis_client, Integer scan_size) -> queueList
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
+      private def self.extract_queues_info: (RC::client redis_client, Set[String] lock_queues, Integer scan_size) -> queuesInfo
     end
   end
 end

data/sig/redis_queued_locks/acquirer/reindex_locks.rbs

@@ -0,0 +1,31 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ReindexLocks
+      type reindexResult = { ok: bool, result: { idx_key_cnt: Integer } }
+      def self.reindex_locks: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer queue_ttl,
+        Integer lock_index_grace_period
+      ) -> reindexResult
+
+      private def self.index_lock_keys: (
+        RC::client redis_client,
+        Array[String] lock_keys,
+        Array[String] lock_queues,
+        Integer queue_pttl,
+        Integer lock_index_grace_period
+      ) -> Integer
+
+      private def self.index_lock_key: (
+        RedisClient::Pipeline pipeline,
+        String key,
+        Integer key_ttl,
+        Integer lock_index_time,
+        Integer lock_index_grace_period
+      ) -> Integer
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/release_all_locks.rbs

@@ -10,6 +10,7 @@ module RedisQueuedLocks
       def self.release_all_locks: (
         RC::client redis,
         Integer batch_size,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped instrument,
@@ -24,7 +25,13 @@ module RedisQueuedLocks
       ) -> releaseResult
 
       type fullRelesaeResult = { ok: bool, result: { rel_key_cnt: Integer } }
-      private def self.fully_release_all_locks: (RC::client redis, Integer batch_size) -> fullRelesaeResult
+      private def self.fully_release_all_locks: (
+        RC::client redis,
+        Integer batch_size,
+        bool lock_index_enabled
+      ) -> fullRelesaeResult
+      private def self.release_locks: (RC::client redis_client, Array[String] lock_names) -> Integer
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
     end
   end
 end

data/sig/redis_queued_locks/acquirer/release_lock.rbs

@@ -19,6 +19,7 @@ module RedisQueuedLocks
       def self.release_lock: (
         RC::client redis,
         String lock_name,
+        bool lock_index_enabled,
         RQL::instrObj instrumenter,
         RQL::loggerObj logger,
         bool log_sampling_enabled,
@@ -38,7 +39,8 @@ module RedisQueuedLocks
         String lock_key,
         String lock_key_queue,
         String read_lock_key_queue,
-        String lock_readers_key
+        String lock_readers_key,
+        bool lock_index_enabled
       ) -> fullReleaseResult
     end
   end

data/sig/redis_queued_locks/acquirer/release_locks_of.rbs

@@ -20,6 +20,7 @@ module RedisQueuedLocks
         RC::client redis,
         Integer lock_scan_size,
         Integer queue_scan_size,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped instrument,
@@ -39,8 +40,26 @@ module RedisQueuedLocks
         String refused_acquirer_id,
         RC::client redis,
         Integer locks_scan_size,
-        Integer queue_scan_size
+        Integer queue_scan_size,
+        bool lock_index_enabled
       ) -> fullyReleaseAllLocksResult
+      private def self.release_refused_locks: (
+        RC::client redis_client,
+        Array[String] lock_keys,
+        String refused_host_id,
+        String refused_acquirer_id
+      ) -> Integer
+      private def self.release_refused_read_locks: (
+        RC::client redis_client,
+        Array[String] lock_readers_keys,
+        String refused_acquirer_id
+      ) -> Integer
+      private def self.dequeue_refused_acquirer: (
+        RC::client redis_client,
+        Array[String] lock_queues,
+        String refused_acquirer_id
+      ) -> Integer
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
     end
   end
 end

data/sig/redis_queued_locks/client.rbs

@@ -36,6 +36,7 @@ module RedisQueuedLocks
       String lock_name,
       ?ttl: Integer,
       ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
       ?timeout: Integer?,
       ?timed: bool,
       ?retry_count: Integer?,
@@ -67,6 +68,7 @@ module RedisQueuedLocks
       String lock_name,
       ?ttl: Integer,
       ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
       ?timeout: Integer?,
       ?timed: bool,
       ?retry_count: Integer?,
@@ -252,5 +254,11 @@ module RedisQueuedLocks
       ?instr_sampler: RQL::Instrument::samplerObj,
       ?instr_sample_this: bool
     ) -> RQL::Acquirer::ClearDeadRequests::clearResult
+
+    def reindex_locks: (
+      ?scan_size: Integer,
+      ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer
+    ) -> RQL::Acquirer::ReindexLocks::reindexResult
   end
 end

data/sig/redis_queued_locks/resource.rbs

@@ -6,7 +6,9 @@ module RedisQueuedLocks
     READ_LOCK_QUEUE_PATTERN: String
     LOCK_READERS_PATTERN: String
     READ_LOCK_PATTERN: String
+    ALL_LOCK_QUEUES_PATTERN: String
     SWARM_KEY: String
+    LOCK_INDEX_KEY: String
     REDIS_TIMESHIFT_ERROR: Integer
 
     def self.calc_uniq_identity: () -> String
@@ -31,6 +33,10 @@ module RedisQueuedLocks
     def self.prepare_lock_readers: (String lock_name) -> String
     def self.prepare_read_lock_key: (String lock_name, String acquirer_id) -> String
     def self.lock_queue_rw_mode: (String lock_queue) -> String?
+    type lockKeyFamily = :lock | :lock_queue | :lock_readers | :read_lock_queue | :read_lock
+    def self.lock_key_family: (String key) -> lockKeyFamily?
+    def self.lock_name_from_key: (String key, lockKeyFamily? key_family) -> String?
+    def self.lock_index_time: () -> Integer
     def self.lock_name_from_readers: (String lock_readers_key) -> String
     def self.lock_key_from_readers: (String lock_readers_key) -> String
     def self.host_identifier_from_acquirer: (String acquirer_id) -> String

data/sig/redis_queued_locks/swarm/flush_zombies.rbs

@@ -4,7 +4,57 @@ module RedisQueuedLocks
   class Swarm
     class FlushZombies < SwarmElement::Isolated
       type flushedZombies = { ok: bool, deleted_zombie_hosts: Set[String], deleted_zombie_acquirers: Set[String], deleted_zombie_locks: Set[String] }
-      def self.flush_zombies: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size, Integer queue_scan_size) -> flushedZombies
+      def self.flush_zombies: (
+        RC::client redis_client,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        Integer queue_scan_size,
+        bool lock_index_enabled
+      ) -> flushedZombies
+      private def self.flush_keyspace_zombies: (
+        RC::client rconn,
+        Set[String] zombie_hosts,
+        Integer lock_scan_size,
+        Integer queue_scan_size,
+        Set[String] zombie_locks,
+        Set[String] zombie_acquirers
+      ) -> void
+      private def self.flush_lock_index_zombies: (
+        RC::client rconn,
+        Set[String] zombie_hosts,
+        Integer lock_scan_size,
+        Integer queue_scan_size,
+        Set[String] zombie_locks,
+        Set[String] zombie_acquirers
+      ) -> void
+      private def self.batch_zombie_requests: (
+        RC::client redis_client,
+        Array[String] lock_queues,
+        String lock_queue,
+        Integer queue_scan_size,
+        Set[String] zombie_hosts,
+        Set[String] zombie_acquirers
+      ) -> void
+      private def self.flush_zombie_locks: (
+        RC::client redis_client,
+        Array[String] lock_keys,
+        Set[String] zombie_hosts,
+        Set[String] zombie_locks,
+        Set[String] zombie_acquirers
+      ) -> void
+      private def self.flush_zombie_read_locks: (
+        RC::client redis_client,
+        Array[String] lock_readers_keys,
+        Set[String] zombie_hosts,
+        Set[String] zombie_locks,
+        Set[String] zombie_acquirers
+      ) -> void
+      private def self.flush_zombie_requests: (
+        RC::client redis_client,
+        Array[String] lock_queues,
+        Set[String] zombie_hosts,
+        Set[String] zombie_acquirers
+      ) -> void
 
       def enabled?: () -> bool
       def spawn_swarm_element!: (Ractor::Port[SwarmElement::Isolated::resultsPortMessage] swarm_element_results_port) -> Ractor

data/sig/redis_queued_locks/swarm/zombie_info.rbs

@@ -4,25 +4,76 @@ module RedisQueuedLocks
   class Swarm
     module ZombieInfo
       type zombieInfo = { zombie_hosts: Set[String], zombie_acquirers: Set[String], zombie_locks: Set[String] }
-      def self.zombies_info: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieInfo
+      def self.zombies_info: (
+        RC::client redis_client,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieInfo
 
       type zombieLocks = Set[String]
-      def self.zombie_locks: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieLocks
+      def self.zombie_locks: (
+        RC::client redis_client,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieLocks
 
       type zombieHosts = Set[String]
       def self.zombie_hosts: (RC::client redis_client, Integer zombie_ttl) -> zombieHosts
 
       type zombieAcquirers = Set[String]
-      def self.zombie_acquirers: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieAcquirers
+      def self.zombie_acquirers: (
+        RC::client redis_client,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieAcquirers
 
       private def self.extract_zombie_hosts: (RC::client rconn, Integer zombie_ttl) -> zombieHosts
-      private def self.extract_zombie_locks: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieLocks
-      private def self.extract_zombie_acquirers: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieAcquirers
-      private def self.extract_all: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieInfo
-      private def self.each_zombie_read_lock: (
+      private def self.extract_zombie_locks: (
+        RC::client rconn,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieLocks
+      private def self.extract_zombie_acquirers: (
+        RC::client rconn,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieAcquirers
+      private def self.extract_all: (
+        RC::client rconn,
+        Integer zombie_ttl,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) -> zombieInfo
+      private def self.each_zombie_lock: (
+        RC::client rconn,
+        Set[String] zombie_hosts,
+        Integer lock_scan_size,
+        bool lock_index_enabled
+      ) { (String lock_key, String acquirer_id) -> void } -> void
+      private def self.each_keyspace_zombie_lock: (
         RC::client rconn,
         Set[String] zombie_hosts,
         Integer lock_scan_size
+      ) { (String lock_key, String acquirer_id) -> void } -> void
+      private def self.each_lock_index_zombie_lock: (
+        RC::client rconn,
+        Set[String] zombie_hosts,
+        Integer lock_scan_size
+      ) { (String lock_key, String acquirer_id) -> void } -> void
+      private def self.each_zombie_write_lock: (
+        RC::client rconn,
+        Array[String] lock_keys,
+        Set[String] zombie_hosts
+      ) { (String lock_key, String acquirer_id) -> void } -> void
+      private def self.each_zombie_read_lock: (
+        RC::client rconn,
+        Array[String] lock_readers_keys,
+        Set[String] zombie_hosts
       ) { (String lock_readers_key, String acquirer_id) -> void } -> void
     end
   end

data/sig/vendor/redis_client.rbs

@@ -3,6 +3,7 @@ class RedisClient
     def call: (*untyped) -> untyped
     def pipelined: () { (Pipeline pipeline) -> untyped } -> untyped
     def scan: (*untyped) { (String key) -> untyped } -> untyped
+    def zscan: (String key, *untyped) { (String member, String score) -> untyped } -> untyped
     def multi: (?watch: Array[String]) { (Multi transact) -> untyped } -> untyped
     def with: (?untyped) { (::RedisClient|::RedisClient::Pooled rconn) -> untyped } -> untyped
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.19.0
+  version: 1.20.0
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -44,6 +44,9 @@ files:
 - ".claude/rules/tests.md"
 - ".claude/rules/type-checking.md"
 - ".claude/rules/visitors.md"
+- ".claude/skills/rql-code-review/SKILL.md"
+- ".claude/skills/rql-code-review/templates/report.en.md"
+- ".claude/skills/rql-code-review/templates/report.ru.md"
 - ".rspec"
 - ".rubocop.rbs.yml"
 - ".rubocop.yml"
@@ -81,6 +84,7 @@ files:
 - lib/redis_queued_locks/acquirer/locks.rb
 - lib/redis_queued_locks/acquirer/queue_info.rb
 - lib/redis_queued_locks/acquirer/queues.rb
+- lib/redis_queued_locks/acquirer/reindex_locks.rb
 - lib/redis_queued_locks/acquirer/release_all_locks.rb
 - lib/redis_queued_locks/acquirer/release_lock.rb
 - lib/redis_queued_locks/acquirer/release_locks_of.rb
@@ -139,6 +143,7 @@ files:
 - sig/redis_queued_locks/acquirer/locks.rbs
 - sig/redis_queued_locks/acquirer/queue_info.rbs
 - sig/redis_queued_locks/acquirer/queues.rbs
+- sig/redis_queued_locks/acquirer/reindex_locks.rbs
 - sig/redis_queued_locks/acquirer/release_all_locks.rbs
 - sig/redis_queued_locks/acquirer/release_lock.rbs
 - sig/redis_queued_locks/acquirer/release_locks_of.rbs