redis_queued_locks 1.19.0 → 1.21.0

data/sig/redis_queued_locks/acquirer/acquire_lock/try_to_lock.rbs

@@ -6,6 +6,13 @@ module RedisQueuedLocks
     module AcquireLock
       module TryToLock
         EXTEND_LOCK_PTTL: String
+        NO_LOCK_DATA: Hash[String, untyped]
+        LOCK_STATE_OBTAINER_REPLY: Integer
+        LOCK_STATE_REDIS_TIME_REPLY: Integer
+        LOCK_STATE_OWN_READ_LOCK_REPLY: Integer
+        LOCK_STATE_QUEUE_REPLIES_AT: Integer
+        QUEUE_HEAD_REPLY: Integer
+        OPPOSITE_QUEUE_HEAD_REPLY: Integer
 
         # { ok: bool, result: Symbol }
         # { ok: bool, result: Symbol }
@@ -31,19 +38,118 @@ module RedisQueuedLocks
           String lock_key_queue,
           String read_lock_key_queue,
           String lock_readers_key,
-          String read_lock_key,
+          String? read_lock_key,
+          String lock_name,
           String acquirer_id,
           String host_id,
           Integer|Float acquirer_position,
           Integer? ttl,
           Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
           bool fail_fast,
           Symbol conflict_strategy,
           Symbol access_strategy,
           Hash[String|Symbol,untyped]? meta,
+          bool retry_attempt,
           bool log_sampled,
           bool instr_sampled
         ) -> { ok: bool, result: Symbol|Hash[Symbol,untyped] }
+
+        private
+
+        def queue_lock_request: (
+          RedisClient::Pipeline pipeline,
+          String request_queue,
+          String opposite_request_queue,
+          Integer|Float acquirer_position,
+          String acquirer_id,
+          Float acquirer_dead_score,
+          String lock_name,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def pipeline_lock_state: (
+          RedisClient::Pipeline pipeline,
+          String lock_key,
+          String lock_readers_key,
+          String acquirer_id,
+          bool read_mode,
+          bool queueing,
+          String request_queue,
+          String opposite_request_queue,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          String lock_name,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def find_opposite_request_ahead: (
+          Symbol access_strategy,
+          [String, Float]? opposite_waiting_request,
+          Integer|Float acquirer_position,
+          String acquirer_id
+        ) -> String?
+
+        type lockObstacle = :dead_score_reached
+                          | :acquirer_is_not_first_in_queue
+                          | :write_request_is_ahead
+                          | :read_request_is_ahead
+                          | :lock_is_still_acquired
+                          | :read_lock_is_still_acquired
+
+        def lock_obstacle: (
+          bool read_mode,
+          Symbol access_strategy,
+          String acquirer_id,
+          String? waiting_acquirer,
+          String? opposite_request_ahead,
+          String? current_lock_obtainer,
+          bool read_locked
+        ) -> lockObstacle?
+
+        def log_lock_obstacle: (
+          RC::client rconn,
+          Symbol obstacle,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy,
+          Symbol read_write_mode,
+          String? waiting_acquirer,
+          String? opposite_request_ahead,
+          String? current_lock_obtainer
+        ) -> void
+
+        def precheck_lock: (
+          RC::client rconn,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          String lock_key,
+          Symbol read_write_mode,
+          String lock_readers_key,
+          String request_queue,
+          String opposite_request_queue,
+          String lock_name,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
+          bool fail_fast,
+          Symbol access_strategy
+        ) -> (lockObstacle | :fail_fast_no_try)?
       end
     end
   end

data/sig/redis_queued_locks/acquirer/acquire_lock/yield_expire.rbs

@@ -12,14 +12,14 @@ module RedisQueuedLocks
           RQL::loggerObj logger,
           String lock_key,
           String lock_readers_key,
-          String read_lock_key,
+          String? read_lock_key,
           Symbol rw_mode,
           String acquirer_id,
           String host_id,
           Symbol access_strategy,
           bool timed,
           Integer|Float ttl_shift,
-          Integer? ttl,
+          Integer ttl,
           Integer queue_ttl,
           Hash[String|Symbol,untyped]? meta,
           bool log_sampled,
@@ -33,7 +33,7 @@ module RedisQueuedLocks
         def yield_with_timeout: (
           Float timeout,
           String lock_key,
-          Integer? lock_ttl,
+          Integer lock_ttl,
           String acquirer_id,
           String host_id,
           Hash[String|Symbol,untyped]? meta,

data/sig/redis_queued_locks/acquirer/acquire_lock.rbs

@@ -19,8 +19,10 @@ module RedisQueuedLocks
         thread_id: Integer|String,
         fiber_id: Integer|String,
         ractor_id: Integer|String,
-        ttl: Integer?,
+        ttl: Integer,
         queue_ttl: Integer,
+        lock_index_enabled: bool,
+        lock_index_grace_period: Integer,
         timeout: Integer?,
         timed: bool,
         retry_count: Integer?,

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -4,11 +4,14 @@ use RedisClient as RC
 module RedisQueuedLocks
   module Acquirer
     module ClearDeadRequests
+      extend RQL::Utilities
+
       type clearResult = { ok: bool, result: { processed_queues: Set[String] } }
       def self.clear_dead_requests: (
         RC::client redis_client,
         Integer scan_size,
         Integer dead_ttl,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped? instrument,
@@ -22,7 +25,22 @@ module RedisQueuedLocks
         bool instr_sample_this
       ) -> clearResult
 
-      private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> untyped } -> Enumerator[String]
+      private def self.fully_clear_dead_requests: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer dead_ttl,
+        bool lock_index_enabled
+      ) -> Set[String]
+
+      private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> void } -> void
+      private def self.drop_dead_requests: (RC::client redis_client, Array[String] lock_queues, Float dead_score) -> void
+      private def self.drop_dead_requests_of_locks: (
+        RC::client redis_client,
+        Array[String] lock_names,
+        Float dead_score,
+        Set[String] processed_queues
+      ) -> void
+      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/extend_lock_ttl.rbs

@@ -4,6 +4,8 @@ use RedisClient as RC
 module RedisQueuedLocks
   module Acquirer
     module ExtendLockTTL
+      extend RQL::Utilities
+
       EXTEND_LOCK_PTTL: String
 
       type extendResult = { ok: bool, result: { extended_locks_count: Integer } | Symbol }
@@ -14,32 +16,46 @@ module RedisQueuedLocks
         Symbol read_write_mode,
         bool all_read_locks,
         String acquirer_id,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped? instrument,
-        bool log_samling_enabled,
+        bool log_sampling_enabled,
         Integer log_sampling_percent,
         RQL::Logging::samplerObj log_sampler,
-        bool sample_this,
+        bool log_sample_this,
         bool instr_sampling_enabled,
         Integer instr_sampling_percent,
         RQL::Instrument::samplerObj instr_sampler,
         bool instr_sample_this
       ) -> extendResult
 
+      private def self.fully_extend_lock_ttl: (
+        RC::client redis_client,
+        String lock_name,
+        String lock_key,
+        Integer milliseconds,
+        Symbol read_write_mode,
+        bool all_read_locks,
+        String acquirer_id,
+        bool lock_index_enabled
+      ) -> extendResult
+
       private def self.extend_read_lock_ttl: (
         RC::client redis_client,
         String lock_name,
         String lock_key,
         String acquirer_id,
-        Integer milliseconds
+        Integer milliseconds,
+        bool lock_index_enabled
       ) -> extendResult
 
       private def self.extend_all_read_locks_ttl: (
         RC::client redis_client,
         String lock_name,
         String lock_key,
-        Integer milliseconds
+        Integer milliseconds,
+        bool lock_index_enabled
       ) -> extendResult
     end
   end

data/sig/redis_queued_locks/acquirer/keys.rbs

@@ -4,7 +4,17 @@ module RedisQueuedLocks
   module Acquirer
     module Keys
       type keyList = Set[String]
-      def self.keys: (RC::client redis_client, scan_size: Integer) -> keyList
+
+      KEY_STATE_REPLIES: Integer
+
+      def self.keys: (
+        RC::client redis_client,
+        scan_size: Integer,
+        lock_index_enabled: bool
+      ) -> keyList
+
+      private def self.collect_lock_keys: (RC::client redis_client, Array[String] lock_names, keyList keyset) -> void
+      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/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,52 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ReindexLocks
+      extend RQL::Utilities
+
+      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,
+        RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
+        untyped? instrument,
+        bool log_sampling_enabled,
+        Integer log_sampling_percent,
+        RQL::Logging::samplerObj log_sampler,
+        bool log_sample_this,
+        bool instr_sampling_enabled,
+        Integer instr_sampling_percent,
+        RQL::Instrument::samplerObj instr_sampler,
+        bool instr_sample_this
+      ) -> reindexResult
+
+      private def self.fully_reindex_locks: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer queue_ttl,
+        Integer lock_index_grace_period
+      ) -> Integer
+
+      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,10 +19,12 @@ module RedisQueuedLocks
       def self.release_lock: (
         RC::client redis,
         String lock_name,
-        RQL::instrObj instrumenter,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
+        untyped? instrument,
         bool log_sampling_enabled,
-        Integer log_samplingPercent,
+        Integer log_sampling_percent,
         RQL::Logging::samplerObj log_sampler,
         bool log_sample_this,
         bool instr_sampling_enabled,
@@ -38,7 +40,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/acquirer/release_read_lock.rbs

@@ -19,8 +19,8 @@ module RedisQueuedLocks
         RC::client redis,
         String lock_name,
         String acquirer_id,
-        RQL::instrObj instrumenter,
         RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
         untyped? instrument,
         bool log_sampling_enabled,
         Integer log_sampling_percent,

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?,
@@ -139,7 +141,7 @@ module RedisQueuedLocks
       ?ractor_id: Integer|String,
       ?identity: String
     ) -> String
-    alias ccurrent_acq_id current_acquirer_id
+    alias current_acq_id current_acquirer_id
     alias acq_id current_acquirer_id
 
     def current_host_id: (
@@ -234,7 +236,7 @@ module RedisQueuedLocks
               | (?scan_size: Integer, ?with_info: true) -> RQL::Acquirer::Queues::queuesInfo
               | (?scan_size: Integer, ?with_info: false) -> RQL::Acquirer::Queues::queueList
 
-    def queues_info: (?scan_size: Integer) -> RQL::Acquirer::Queues::queues
+    def queues_info: (?scan_size: Integer) -> RQL::Acquirer::Queues::queuesInfo
     def keys: (?scan_size: Integer) -> RQL::Acquirer::Keys::keyList
 
     def clear_dead_requests: (
@@ -252,5 +254,22 @@ 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,
+      ?logger: RQL::loggerObj,
+      ?instrumenter: RQL::instrObj,
+      ?instrument: untyped?,
+      ?log_sampling_enabled: bool,
+      ?log_sampling_percent: Integer,
+      ?log_sampler: RQL::Logging::samplerObj,
+      ?log_sample_this: bool,
+      ?instr_sampling_enabled: bool,
+      ?instr_sampling_percent: Integer,
+      ?instr_sampler: RQL::Instrument::samplerObj,
+      ?instr_sample_this: bool
+    ) -> RQL::Acquirer::ReindexLocks::reindexResult
   end
 end

data/sig/redis_queued_locks/errors.rbs

@@ -5,10 +5,13 @@ module RedisQueuedLocks
   class ArgumentError < ::ArgumentError
   end
 
+  class Exception < ::Exception
+  end
+
   class LockAlreadyObtainedError < Error
   end
 
-  class LockAcquirementIntermediateTimeoutError < ::Timeout::Error
+  class LockAcquirementIntermediateTimeoutError < Exception
   end
 
   class LockAcquirementTimeoutError < Error
@@ -17,7 +20,7 @@ module RedisQueuedLocks
   class LockAcquirementRetryLimitError < Error
   end
 
-  class TimedLockIntermediateTimeoutError < ::Timeout::Error
+  class TimedLockIntermediateTimeoutError < Exception
   end
 
   class TimedLockTimeoutError < Error

data/sig/redis_queued_locks/instrument/sampler.rbs

@@ -1,8 +1,6 @@
 module RedisQueuedLocks
   module Instrument
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
       def self.sampling_happened?: (Integer sampling_percent) -> bool
     end
   end

data/sig/redis_queued_locks/logging/sampler.rbs

@@ -1,8 +1,6 @@
 module RedisQueuedLocks
   module Logging
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
       def self.sampling_happened?: (Integer sampling_percent) -> bool
     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
@@ -39,7 +45,7 @@ module RedisQueuedLocks
     def self.acquirer_dead_score: (Integer|Float queue_ttl) -> Float
     def self.calc_zombie_score: (Float zombie_ttl) -> Float
     def self.dead_score_reached?: (Float acquirer_position, Integer queue_ttl) -> bool
-    def self.lock_key_from_queue: (String lock_queue) -> String
+    def self.lock_key_from_queue: (String lock_queue) -> String?
     def self.get_thread_id: () -> Integer
     def self.get_fiber_id: () -> Integer
     def self.get_ractor_id: () -> Integer

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