redis_queued_locks 1.12.0 → 1.13.0

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

@@ -0,0 +1,71 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module InstrVisitor
+        def self.extendable_reentrant_lock_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Integer? ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          untyped? instrument
+        ) -> void
+
+        def self.reentrant_lock_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Integer? ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Integer? ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          untyped? instrument
+        ) -> void
+
+        def self.reentrant_lock_hold_completes: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Integer? ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Integer|Float hold_time,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_hold_and_release: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Integer? ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Integer|Float hold_time,
+          untyped? instrument
+        ) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module LogVisitor
+        def self.start_lock_obtaining: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy
+        ) -> void
+
+        def self.start_try_to_lock_cycle: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy
+        ) -> void
+
+        def self.dead_score_reached__reset_acquirer_position: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy
+        ) -> void
+
+        def self.extendable_reentrant_lock_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          Symbol access_strategy
+        ) -> void
+
+        def self.reentrant_lock_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          Symbol access_strategy
+        ) -> void
+
+        def self.lock_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          Symbol access_strategy
+        ) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module TryToLock
+        module LogVisitor
+          def self.start: (
+            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
+          ) -> void
+
+          def self.rconn_fetched: (
+            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
+          ) -> void
+
+          def self.same_process_conflict_detected: (
+            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
+          ) -> void
+
+          def self.same_process_conflict_analyzed: (
+            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 sp_conflict_status
+          ) -> void
+
+          def self.reentrant_lock__extend_and_work_through: (
+            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 sp_conflict_status,
+            Integer? ttl,
+            ::Float spc_processed_timestamp
+          ) -> void
+
+          def self.reentrant_lock__work_through: (
+            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 sp_conflict_status,
+            ::Float spc_processed_timestamp
+          ) -> void
+
+          def self.single_process_lock_conflict__dead_lock: (
+            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 sp_conflict_status,
+            ::Float spc_processed_timestamp
+          ) -> void
+
+          def self.acq_added_to_queue: (
+            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
+          ) -> void
+
+          def self.remove_expired_acqs: (
+            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
+          ) -> void
+
+          def self.get_first_from_queue: (
+            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,
+            String? waiting_acquirer
+          ) -> void
+
+          def self.exit__queue_ttl_reached: (
+            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
+          ) -> void
+
+          def self.exit__no_first: (
+            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,
+            String? waiting_acquirer,
+            Hash[String,untyped] current_lock_data
+          ) -> void
+
+          def self.exit__lock_still_obtained: (
+            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,
+            String? waiting_acquirer,
+            String locked_by_acquirer,
+            Hash[String,untyped] current_lock_data
+          ) -> void
+
+          def self.obtain__free_to_acquire: (
+            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
+          ) -> void
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module TryToLock
+        EXTEND_LOCK_PTTL: String
+
+        # { ok: bool, result: Symbol }
+        # { ok: bool, result: Symbol }
+        # {
+        #   ok: bool,
+        #   result: {
+        #     process: Symbol,
+        #     lock_key: String,
+        #     acq_id: String,
+        #     hst_id: String,
+        #     ts: Integer?,
+        #     ttl: Integer?
+        #   }
+        # }
+
+        def try_to_lock: (
+          RC::client redis,
+          RQL::loggerObj logger,
+          bool log_lock_try,
+          String lock_key,
+          Symbol read_write_mode,
+          String lock_key_queue,
+          String read_lock_key_queue,
+          String write_lock_key_queue,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acquirer_position,
+          Integer? ttl,
+          Integer queue_ttl,
+          bool fail_fast,
+          Symbol conflict_strategy,
+          Symbol access_strategy,
+          Hash[String|Symbol,untyped]? meta,
+          bool log_sampled,
+          bool instr_sampled
+        ) -> { ok: bool, result: Symbol|Hash[Symbol,untyped] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module WithAcqTimeout
+        def with_acq_timeout: (
+          RC::client redis,
+          Integer? timeout,
+          String lock_key,
+          String lock_name,
+          bool raise_errors,
+          bool detailed_acq_timeout_error,
+          ?on_timeout: Proc|nil
+        ) { (?) -> untyped } -> untyped
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module YieldExpire
+        DECREASE_LOCK_PTTL: String
+
+        def yield_expire: (
+          RC::client redis,
+          RQL::loggerObj logger,
+          String lock_key,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy,
+          bool timed,
+          Integer|Float ttl_shift,
+          Integer? ttl,
+          Integer queue_ttl,
+          Hash[String|Symbol,untyped]? meta,
+          bool log_sampled,
+          bool instr_sampled,
+          bool should_expire,
+          bool should_decrease
+        ) ?{ (?) -> untyped } -> untyped?
+
+        private
+
+        def yield_with_timeout: (
+          Float timeout,
+          String lock_key,
+          Integer? lock_ttl,
+          String acquirer_id,
+          String host_id,
+          Hash[String|Symbol,untyped]? meta,
+        ) { (?) -> untyped } -> untyped
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/acquire_lock/yield_with_expire/log_visitor.rbs

@@ -0,0 +1,32 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module YieldExpire
+        module LogVisitor
+          def self.expire_lock: (
+            RQL::loggerObj logger,
+            bool log_sampled,
+            String lock_key,
+            Integer queue_ttl,
+            String acquirer_id,
+            String host_id,
+            Symbol access_strategy
+          ) -> void
+
+          def self.decrease_lock: (
+            RQL::loggerObj logger,
+            bool log_sampled,
+            String lock_key,
+            Integer decreased_ttl,
+            Integer queue_ttl,
+            String acquirer_id,
+            String host_id,
+            Symbol access_strategy
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/acquire_lock.rbs

@@ -0,0 +1,51 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      extend RQL::Acquirer::AcquireLock::TryToLock
+      extend RQL::Acquirer::AcquireLock::DelayExecution
+      extend RQL::Acquirer::AcquireLock::YieldExpire
+      extend RQL::Acquirer::AcquireLock::WithAcqTimeout
+      extend RQL::Acquirer::AcquireLock::DequeueFromLockQueue
+
+      type acquireResult = ({ ok: bool, result: untyped }|untyped)
+      def self.acquire_lock: (
+        RC::client redis,
+        String lock_name,
+        process_id: Integer|String,
+        thread_id: Integer|String,
+        fiber_id: Integer|String,
+        ractor_id: Integer|String,
+        ttl: Integer?,
+        queue_ttl: Integer,
+        timeout: Integer?,
+        timed: bool,
+        retry_count: Integer?,
+        retry_delay: Integer,
+        retry_jitter: Integer,
+        raise_errors: bool,
+        instrumenter: RQL::instrObj,
+        identity: String,
+        fail_fast: bool,
+        meta: Hash[String|Symbol,untyped]?,
+        detailed_acq_timeout_error: bool,
+        logger: RQL::loggerObj,
+        log_lock_try: bool,
+        instrument: untyped?,
+        conflict_strategy: Symbol,
+        read_write_mode: Symbol,
+        access_strategy: Symbol,
+        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
+      ) ?{ (?) -> untyped } -> acquireResult
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -0,0 +1,28 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ClearDeadRequests
+      type clearResult = { ok: bool, result: { processed_queues: Set[String] } }
+      def self.clear_dead_requests: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer dead_ttl,
+        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
+      ) -> clearResult
+
+      private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> untyped } -> Enumerator[String]
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/extend_lock_ttl.rbs

@@ -0,0 +1,28 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ExtendLockTTL
+      EXTEND_LOCK_PTTL: String
+
+      type extendResult = { ok: bool, result: Symbol }
+      def self.extend_lock_ttl: (
+        RC::client redis_client,
+        String lock_name,
+        Integer milliseconds,
+        RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
+        untyped? instrument,
+        bool log_samling_enabled,
+        Integer log_sampling_percent,
+        RQL::Logging::samplerObj log_sampler,
+        bool sample_this,
+        bool instr_sampling_enabled,
+        Integer instr_sampling_percent,
+        RQL::Instrument::samplerObj instr_sampler,
+        bool instr_sample_this
+      ) -> extendResult
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/is_locked.rbs

@@ -0,0 +1,9 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module IsLocked
+      def self.locked?: (RC::client redis_client, String lock_name) -> bool
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/is_queued.rbs

@@ -0,0 +1,9 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module IsQueued
+      def self.queued?: (RC::client redis_client, String lock_name) -> bool
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/keys.rbs

@@ -0,0 +1,10 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module Keys
+      type keyList = Set[String]
+      def self.keys: (RC::client redis_client, scan_size: Integer) -> keyList
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/lock_info.rbs

@@ -0,0 +1,10 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockInfo
+      type lockInfo = Hash[String,String|Float|Integer]
+      def self.lock_info: (RC::client redis_client, String lock_name) -> lockInfo?
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/locks.rbs

@@ -0,0 +1,16 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module Locks
+      type lockList = Set[String]
+      type locksInfo = Set[{ lock: String, status: Symbol, info: Hash[String,String|Float|Integer] }]
+      type locks = lockList | locksInfo
+
+      def self.locks: (RC::client redis_client, scan_size: Integer, with_info: 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
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/queue_info.rbs

@@ -0,0 +1,13 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module QueueInfo
+      type queueInfo = {
+        'lock_queue' => String,
+        'queue' => Array[{ 'acq_id' => String, 'score' => Integer|Float }]
+      }
+      def self.queue_info: (RC::client redis_client, String lock_name) -> queueInfo?
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/queues.rbs

@@ -0,0 +1,16 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module Queues
+      type queueList = Set[String]
+      type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,Float]] }]
+      type queues = queueList | queuesInfo
+
+      def self.queues: (RC::client redis_client, scan_size: Integer, with_info: 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
+    end
+  end
+end