redis_queued_locks 1.21.0 → 1.23.0

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

@@ -0,0 +1,102 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockSeries
+      module InstrVisitor
+        def self.lock_series_intermediate_lock_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_series_lock_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_series_lock_obtaining_failed: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Symbol result,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_series_obtained: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Array[String] reentrant_lock_keys,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_series_hold_and_release: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Integer|Float hold_time,
+          Array[String] reentrant_lock_keys,
+          untyped? instrument
+        ) -> void
+
+        def self.lock_series_obtaining_failed: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Symbol result,
+          String? failed_lock_key,
+          untyped? instrument
+        ) -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockSeries
+      module LogVisitor
+        def self.start_lock_series_obtaining: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.start_try_to_lock_series_cycle: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.dead_score_reached__reset_series_position: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.dequeue_from_lock_series_queues: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.expire_lock_series: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.lock_series_intermediate_lock_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.lock_series_lock_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def self.lock_series_lock_obtaining_failed: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Symbol result
+        ) -> void
+
+        def self.lock_series_obtained: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Array[String] reentrant_lock_keys
+        ) -> void
+
+        def self.lock_series_obtaining_failed: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority,
+          Symbol result,
+          String? failed_lock_key
+        ) -> void
+
+        def self.decrease_lock_series: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          Array[String] lock_keys,
+          Integer decreased_ttl,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/lock_series/release_lock_series.rbs

@@ -0,0 +1,37 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockSeries
+      module ReleaseLockSeries
+        def release_lock_series: (
+          RC::client redis,
+          Array[String] lock_names,
+          Array[Symbol?] lock_processes,
+          Array[RQL::readWriteMode] held_rw_modes,
+          String acquirer_id,
+          Integer decreased_ttl
+        ) -> void
+
+        private
+
+        def release_write_lock_series: (
+          RC::client redis,
+          Array[String] lock_names,
+          Array[String] extended_lock_names,
+          String acquirer_id,
+          Integer decreased_ttl
+        ) -> void
+
+        def release_read_lock_series: (
+          RC::client redis,
+          Array[String] lock_names,
+          Array[String] extended_lock_names,
+          String acquirer_id,
+          Integer decreased_ttl
+        ) -> void
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/lock_series/try_to_lock_series.rbs

@@ -0,0 +1,198 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockSeries
+      module TryToLockSeries
+        include RQL::Acquirer::AcquireLock::TryToLock
+        include RQL::Acquirer::LockSeries::ReleaseLockSeries
+
+        type attemptResult = { ok: bool, result: Symbol, lock_name: String?, ready_locks: Array[Integer] }
+        type seriesObstacle = [Symbol, Integer]
+        type deadRequests = [Integer, [[String, Float]?, Integer?, [String, Float]?, Integer?]]
+        type lockState = {
+          obtainer: String?,
+          redis_time: Integer,
+          own_read_lock_expiration: Float?,
+          read_locked: bool,
+          conflict_rw_mode: RQL::readWriteMode?,
+          queued: bool,
+          waiting_request: [String, Float]?,
+          opposite_waiting_request: [String, Float]?,
+          dropped_requests: Array[[String, Integer]]?
+        }
+
+        def try_to_lock_series: (
+          RC::client redis,
+          RQL::loggerObj logger,
+          bool log_lock_try,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Array[String] lock_key_queues,
+          Array[String] read_lock_key_queues,
+          Array[String] lock_readers_keys,
+          Array[String?] read_lock_keys,
+          Array[String] lock_names,
+          Array[String] watched_keys,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acquirer_position,
+          Integer priority,
+          Integer ttl,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
+          bool fail_fast,
+          RQL::conflictStrategy conflict_strategy,
+          RQL::accessStrategy access_strategy,
+          Hash[String|Symbol,untyped]? meta,
+          bool retry_attempt,
+          Hash[Symbol,untyped] acq_process,
+          bool log_sampled
+        ) -> attemptResult
+
+        private
+
+        def pipeline_series_lock_state: (
+          RedisClient::Pipeline pipeline,
+          Array[String] lock_keys,
+          Array[String] lock_readers_keys,
+          String acquirer_id,
+          bool read_mode,
+          bool queueing,
+          Array[String] request_queues,
+          Array[String] opposite_request_queues,
+          Integer|Float acquirer_position,
+          Integer priority,
+          Float acquirer_dead_score,
+          Array[String] lock_names,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def series_lock_state_replies: (
+          bool read_mode,
+          bool queueing,
+          bool lock_index_enabled
+        ) -> Integer
+
+        def series_queue_replies: (bool lock_index_enabled) -> Integer
+
+        def series_lock_states: (
+          Array[untyped] state_replies,
+          Integer locks_count,
+          String acquirer_id,
+          bool read_mode,
+          bool queueing,
+          bool lock_index_enabled
+        ) -> Array[lockState]
+
+        def queue_series_lock_requests: (
+          RC::client rconn,
+          Array[lockState] lock_states,
+          Array[Symbol?] lock_processes,
+          Array[String] request_queues,
+          Array[String] opposite_request_queues,
+          Integer|Float acquirer_position,
+          Integer priority,
+          String acquirer_id,
+          Float acquirer_dead_score,
+          Array[String] lock_names,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def drop_series_dead_requests_ahead: (
+          RC::client rconn,
+          bool read_mode,
+          Array[String] request_queues,
+          Array[String] opposite_request_queues,
+          Array[lockState] lock_states,
+          String acquirer_id,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          RQL::accessStrategy access_strategy
+        ) -> void
+
+        def find_series_lock_obstacle: (
+          Array[lockState] lock_states,
+          bool read_mode,
+          RQL::accessStrategy access_strategy,
+          String acquirer_id,
+          Integer|Float acquirer_position,
+          Array[Integer] ready_locks
+        ) -> seriesObstacle?
+
+        def log_series_queueing: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          Array[String] lock_keys,
+          Array[lockState] lock_states,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode,
+          Integer priority
+        ) -> void
+
+        def log_series_dropped_requests: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          Array[String] lock_keys,
+          Array[lockState] lock_states,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode
+        ) -> void
+
+        def log_series_lock_obstacle: (
+          RC::client rconn,
+          Symbol obstacle,
+          Integer lock_index,
+          Array[lockState] lock_states,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          Array[String] lock_keys,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode rw_mode
+        ) -> void
+
+        def precheck_lock_series: (
+          RC::client rconn,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          Array[String] lock_keys,
+          RQL::readWriteMode rw_mode,
+          Array[String] lock_readers_keys,
+          Array[String] request_queues,
+          Array[String] opposite_request_queues,
+          Array[String] lock_names,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acquirer_position,
+          Integer priority,
+          Float acquirer_dead_score,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
+          bool fail_fast,
+          RQL::accessStrategy access_strategy,
+          Array[Integer] ready_locks
+        ) -> seriesObstacle?
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/lock_series.rbs

@@ -0,0 +1,106 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module LockSeries
+      extend RQL::Utilities
+      extend RQL::Acquirer::AcquireLock::DelayExecution
+      extend RQL::Acquirer::AcquireLock::YieldExpire
+      extend RQL::Acquirer::LockSeries::TryToLockSeries
+
+      type lockSeriesResult = ({ ok: bool, result: untyped }|untyped)
+      def self.lock_series: (
+        RC::client redis,
+        Array[String] lock_names,
+        detailed_result: bool,
+        process_id: Integer|String,
+        thread_id: Integer|String,
+        fiber_id: Integer|String,
+        ractor_id: Integer|String,
+        ttl: Integer,
+        queue_ttl: Integer,
+        lock_index_enabled: bool,
+        lock_index_grace_period: 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,
+        instrument: untyped?,
+        logger: RQL::loggerObj,
+        log_lock_try: bool,
+        conflict_strategy: RQL::conflictStrategy,
+        rw_mode: Symbol, # NOTE: (rbs test) validated at runtime (Step 0.1 (RW)): any Symbol is accepted here
+        access_strategy: RQL::accessStrategy,
+        priority: RQL::lockPriority,
+        lock_priorities: Hash[Symbol, Integer],
+        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 } -> lockSeriesResult
+
+      private def self.yield_lock_series: (
+        Array[String] lock_keys,
+        String acquirer_id,
+        String host_id,
+        bool timed,
+        Integer|Float ttl_shift,
+        Integer ttl,
+        Hash[String|Symbol,untyped]? meta
+      ) ?{ (?) -> untyped } -> untyped?
+
+      private def self.complete_lock_series_release: (
+        RC::client redis,
+        Array[String] lock_names,
+        Array[Symbol?] lock_processes,
+        Array[RQL::readWriteMode] held_rw_modes,
+        String acquirer_id,
+        Integer decreased_ttl
+      ) -> void
+
+      private def self.drop_failed_lock_series: (
+        RC::client redis,
+        RQL::loggerObj logger,
+        Array[String] lock_keys,
+        RQL::readWriteMode rw_mode,
+        Array[String] lock_key_queues,
+        Array[String] read_lock_key_queues,
+        Array[String] lock_names,
+        Integer queue_ttl,
+        String acquirer_id,
+        String host_id,
+        RQL::accessStrategy access_strategy,
+        Integer priority,
+        Hash[Symbol,untyped] acq_process,
+        bool log_sampled
+      ) -> void
+
+      private def self.raise_lock_series_error: (
+        RC::client redis,
+        Symbol failure_result,
+        Array[String] lock_keys,
+        String? failed_lock_name,
+        String? failed_lock_key,
+        String acquirer_id,
+        RQL::conflictStrategy conflict_strategy,
+        Integer? retry_count,
+        Integer? timeout,
+        bool detailed_acq_timeout_error
+      ) -> void
+
+      private def self.blocking_lock_details: (RC::client redis, String failed_lock_name) -> String
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/queues.rbs

@@ -4,7 +4,7 @@ module RedisQueuedLocks
   module Acquirer
     module Queues
       type queueList = Set[String]
-      type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,String|Float]] }]
+      type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,String|Integer|Float]] }]
       type queues = queueList | queuesInfo
 
       def self.queues: (