redis_queued_locks 1.22.0 → 1.23.0

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/client.rbs

@@ -45,7 +45,7 @@ module RedisQueuedLocks
       ?raise_errors: bool,
       ?fail_fast: bool,
       ?conflict_strategy: RQL::conflictStrategy,
-      ?read_write_mode: RQL::readWriteMode,
+      ?rw_mode: RQL::readWriteMode,
       ?access_strategy: RQL::accessStrategy,
       ?priority: RQL::lockPriority,
       ?identity: String,
@@ -77,7 +77,7 @@ module RedisQueuedLocks
       ?retry_jitter: Integer,
       ?fail_fast: bool,
       ?conflict_strategy: RQL::conflictStrategy,
-      ?read_write_mode: RQL::readWriteMode,
+      ?rw_mode: RQL::readWriteMode,
       ?access_strategy: RQL::accessStrategy,
       ?priority: RQL::lockPriority,
       ?identity: String,
@@ -97,6 +97,73 @@ module RedisQueuedLocks
       ?instr_sample_this: bool,
     ) ?{ (?) -> untyped } -> RQL::Acquirer::AcquireLock::acquireResult
 
+    def lock_series: (
+      *String lock_names,
+      ?detailed_result: bool,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?raise_errors: bool,
+      ?fail_fast: bool,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?rw_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
+      ?identity: String,
+      ?meta: Hash[String|Symbol,untyped]?,
+      ?detailed_acq_timeout_error: bool,
+      ?logger: RQL::loggerObj,
+      ?log_lock_try: bool,
+      ?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
+    ) ?{ (?) -> untyped } -> RQL::Acquirer::LockSeries::lockSeriesResult
+
+    def lock_series!: (
+      *String lock_names,
+      ?detailed_result: bool,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?fail_fast: bool,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?rw_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
+      ?identity: String,
+      ?meta: Hash[String|Symbol,untyped]?,
+      ?detailed_acq_timeout_error: bool,
+      ?logger: RQL::loggerObj,
+      ?log_lock_try: bool,
+      ?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
+    ) ?{ (?) -> untyped } -> RQL::Acquirer::LockSeries::lockSeriesResult
+
     def unlock: (
       String lock_name,
       ?logger: RQL::loggerObj,
@@ -160,7 +227,7 @@ module RedisQueuedLocks
     def extend_lock_ttl: (
       String lock_name,
       Integer milliseconds,
-      ?read_write_mode: RQL::readWriteMode,
+      ?rw_mode: RQL::readWriteMode,
       ?all_read_locks: bool,
       ?identity: String,
       ?logger: RQL::loggerObj,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.22.0
+  version: 1.23.0
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -23,12 +23,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
-description: |-
-  |> Distributed locks with "prioritized lock acquisition queue" capabilities based on the Redis Database.
-  |> Each lock request is put into the request queue (each lock is hosted by its own queue separately from other queues) and processed in order of their priority (FIFO).
-  |> Each lock request lives some period of time (RTTL) (with requeue capabilities) which guarantees the request queue will never be stacked.
-  |> In addition to the classic `queued` (FIFO) strategy RQL supports `random` (RANDOM) lock obtaining strategy when any acquirer from the lock queue can obtain the lock regardless the position in the queue.
-  |> Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), logging and instrumentation.
+description: |
+  RedisQueuedLocks (aka RQL, aka RQL-lock) - distributed locks with
+  "prioritized lock acquisition queue" capabilities based on the Redis Database.
+
+  Each lock request is put into the request queue
+  (each lock is hosted by its own queue separately from other queues)
+  and processed in order of their priority: requests of a higher priority go first,
+  requests of the same priority are processed in FIFO order.
+  Each lock request lives some period of time (RTTL) (with requeue capabilities)
+  which guarantees the request queue will never be stacked.
+
+  In addition to the classic queued (FIFO) strategy RQL supports random (RANDOM)
+  lock obtaining strategy when any acquirer from the lock queue
+  can obtain the lock regardless the position in the queue.
+
+  Supports lock request prioritization, Read/Write locks and Reentrant locks.
+
+  Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl,
+  queue ttl, lock attempts limit, fast failing, etc), zombie locks elimination,
+  lock indexing, logging and instrumentation (and much more).
 email:
 - iamdaiver@gmail.com
 executables: []
@@ -79,9 +93,11 @@ files:
 - lib/redis_queued_locks/acquirer/is_queued.rb
 - lib/redis_queued_locks/acquirer/keys.rb
 - lib/redis_queued_locks/acquirer/lock_info.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series.rb
+- lib/redis_queued_locks/acquirer/lock_series/instr_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series/log_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series/release_lock_series.rb
+- lib/redis_queued_locks/acquirer/lock_series/try_to_lock_series.rb
 - lib/redis_queued_locks/acquirer/locks.rb
 - lib/redis_queued_locks/acquirer/queue_info.rb
 - lib/redis_queued_locks/acquirer/queues.rb
@@ -141,6 +157,11 @@ files:
 - sig/redis_queued_locks/acquirer/is_queued.rbs
 - sig/redis_queued_locks/acquirer/keys.rbs
 - sig/redis_queued_locks/acquirer/lock_info.rbs
+- sig/redis_queued_locks/acquirer/lock_series.rbs
+- sig/redis_queued_locks/acquirer/lock_series/instr_visitor.rbs
+- sig/redis_queued_locks/acquirer/lock_series/log_visitor.rbs
+- sig/redis_queued_locks/acquirer/lock_series/release_lock_series.rbs
+- sig/redis_queued_locks/acquirer/lock_series/try_to_lock_series.rbs
 - sig/redis_queued_locks/acquirer/locks.rbs
 - sig/redis_queued_locks/acquirer/queue_info.rbs
 - sig/redis_queued_locks/acquirer/queues.rbs
@@ -201,7 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.22
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Distributed locks with "prioritized lock acquisition queue" capabilities
   based on the Redis Database.