redis_queued_locks 1.12.1 → 1.14.0

data/lib/redis_queued_locks/swarm/swarm_element/threaded.rb

@@ -35,7 +35,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @since 1.9.0
   attr_reader :swarm_element_commands
 
-  # @return [Thread::SizedQueue]
+  # @return [Thread::SizedQueue,NilClass]
   #
   # @api private
   # @since 1.9.0
@@ -106,7 +106,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   #
   # @api private
   # @since 1.9.0
-  def enabled?
+  def enabled? # steep:ignore
     # NOTE: provide an <is enabled> logic here by analyzing the redis queued locks config.
   end
 
@@ -129,12 +129,12 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   def status
     sync.synchronize do
       thread_running = swarmed__alive?
-      thread_state = swarmed? ? thread_state(swarm_element) : 'non_initialized'
+      thread_state = swarmed? ? thread_state(swarm_element) : 'non_initialized' # steep:ignore
 
       main_loop_running = swarmed__running?
       main_loop_state = begin
         if main_loop_running
-          swarm_loop__status[:result][:main_loop][:state]
+          swarm_loop__status[:result][:main_loop][:state] # steep:ignore
         else
           'non_initialized'
         end
@@ -179,26 +179,34 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
 
     @swarm_element = Thread.new do
       loop do
-        command = swarm_element_commands.pop
+        command = swarm_element_commands.pop # steep:ignore
 
         case command
         when :status
+          # steep:ignore:start
           main_loop_alive = main_loop != nil && main_loop.alive?
+          # steep:ignore:end
+
+          # steep:ignore:start
           main_loop_state = (main_loop == nil) ? 'non_initialized' : thread_state(main_loop)
+          # steep:ignore:end
+
+          # steep:ignore:start
           swarm_element_results.push({
             ok: true,
             result: { main_loop: { alive: main_loop_alive, state: main_loop_state } }
           })
+          # steep:ignore:end
         when :is_active
-          is_active = main_loop != nil && main_loop.alive?
-          swarm_element_results.push({ ok: true, result: { is_active: } })
+          is_active = main_loop != nil && main_loop.alive? # steep:ignore
+          swarm_element_results.push({ ok: true, result: { is_active: } }) # steep:ignore
         when :start
           main_loop&.kill
           @main_loop = spawn_main_loop!.tap { |thread| thread.abort_on_exception = false }
-          swarm_element_results.push({ ok: true, result: nil })
+          swarm_element_results.push({ ok: true, result: nil }) # steep:ignore
         when :stop
           main_loop&.kill
-          swarm_element_results.push({ ok: true, result: nil })
+          swarm_element_results.push({ ok: true, result: nil }) # steep:ignore
         end
       end
     end
@@ -209,7 +217,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   #
   # @api private
   # @since 1.9.0
-  def spawn_main_loop!
+  def spawn_main_loop! # steep:ignore
     # NOTE:
     #   - provide the swarm element looped logic here wrapped into the thread;
     #   - created thread will be reconfigured inside the swarm_element logic with a
@@ -238,7 +246,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @api private
   # @since 1.9.0
   def swarmed__alive?
-    swarmed? && swarm_element.alive? && !terminating?
+    swarmed? && swarm_element.alive? && !terminating? # steep:ignore
   end
 
   # @return [Boolean]
@@ -246,7 +254,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @api private
   # @since 1.9.0
   def swarmed__dead?
-    swarmed? && (!swarm_element.alive? || terminating?)
+    swarmed? && (!swarm_element.alive? || terminating?) # steep:ignore
   end
 
   # @return [Boolean]
@@ -255,7 +263,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @since 1.9.0
   def swarmed__running?
     swarmed__alive? && !terminating? && (swarm_loop__is_active.yield_self do |result|
-      result && result[:ok] && result[:result][:is_active]
+      result != nil && result[:ok] && result[:result][:is_active] # steep:ignore
     end)
   end
 
@@ -278,7 +286,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @since 1.9.0
   def swarmed__stopped?
     swarmed__alive? && (terminating? || !(swarm_loop__is_active.yield_self do |result|
-      result && result[:ok] && result[:result][:is_active]
+      result && result[:ok] && result[:result][:is_active] # steep:ignore
     end))
   end
 
@@ -289,8 +297,8 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   def swarm_loop__is_active
     return if idle? || swarmed__dead? || terminating?
     sync.synchronize do
-      swarm_element_commands.push(:is_active)
-      swarm_element_results.pop
+      swarm_element_commands.push(:is_active) # steep:ignore
+      swarm_element_results.pop # steep:ignore
     end
   end
 
@@ -301,8 +309,8 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   def swarm_loop__status
     return if idle? || swarmed__dead? || terminating?
     sync.synchronize do
-      swarm_element_commands.push(:status)
-      swarm_element_results.pop
+      swarm_element_commands.push(:status) # steep:ignore
+      swarm_element_results.pop # steep:ignore
     end
   end
 
@@ -313,8 +321,8 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   def swarm_loop__start
     return if idle? || swarmed__dead? || terminating?
     sync.synchronize do
-      swarm_element_commands.push(:start)
-      swarm_element_results.pop
+      swarm_element_commands.push(:start) # steep:ignore
+      swarm_element_results.pop # steep:ignore
     end
   end
 
@@ -325,8 +333,8 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   def swarm_loop__stop
     return if idle? || swarmed__dead? || terminating?
     sync.synchronize do
-      swarm_element_commands.push(:stop)
-      swarm_element_results.pop
+      swarm_element_commands.push(:stop) # steep:ignore
+      swarm_element_results.pop # steep:ignore
     end
   end
 
@@ -338,11 +346,11 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
     return if idle? || swarmed__dead?
     sync.synchronize do
       main_loop&.kill
-      swarm_element.kill
-      swarm_element_commands.close
-      swarm_element_results.close
-      swarm_element_commands.clear
-      swarm_element_results.clear
+      swarm_element.kill # steep:ignore
+      swarm_element_commands.close # steep:ignore
+      swarm_element_results.close # steep:ignore
+      swarm_element_commands.clear # steep:ignore
+      swarm_element_results.clear # steep:ignore
       @swarm_element_commands = nil
       @swarm_element_results = nil
     end

data/lib/redis_queued_locks/swarm/zombie_info.rb

@@ -54,9 +54,9 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.9.0
-    def zombie_acquiers(redis_client, zombie_ttl, lock_scan_size)
+    def zombie_acquirers(redis_client, zombie_ttl, lock_scan_size)
       redis_client.with do |rconn|
-        extract_zombie_acquiers(rconn, zombie_ttl, lock_scan_size)
+        extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size)
       end
     end
 
@@ -69,7 +69,7 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # @api private
     # @since 1.9.0
     def extract_zombie_hosts(rconn, zombie_ttl)
-      zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000)
+      zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000.0)
       swarmed_hosts = rconn.call('HGETALL', RedisQueuedLocks::Resource::SWARM_KEY)
       swarmed_hosts.each_with_object(Set.new) do |(hst_id, ts), zombies|
         (zombies << hst_id) if (zombie_score > ts.to_f)
@@ -89,7 +89,7 @@ module RedisQueuedLocks::Swarm::ZombieInfo
       rconn.scan(
         'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
       ) do |lock_key|
-        _acquier_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
+        _acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
         zombie_locks << lock_key if zombie_hosts.include?(host_id)
       end
       zombie_locks
@@ -102,14 +102,14 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.9.0
-    def extract_zombie_acquiers(rconn, zombie_ttl, lock_scan_size)
+    def extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size)
       zombie_hosts = extract_zombie_hosts(rconn, zombie_ttl)
       zombie_acquirers = Set.new
       rconn.scan(
         'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
       ) do |lock_key|
-        acquier_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
-        zombie_acquirers << acquier_id if zombie_hosts.include?(host_id)
+        acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
+        zombie_acquirers << acquirer_id if zombie_hosts.include?(host_id)
       end
       zombie_acquirers
     end
@@ -133,9 +133,9 @@ module RedisQueuedLocks::Swarm::ZombieInfo
       rconn.scan(
         'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
       ) do |lock_key|
-        acquier_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
+        acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
         if zombie_hosts.include?(host_id)
-          zombie_acquirers << acquier_id
+          zombie_acquirers << acquirer_id
           zombie_locks << lock_key
         end
       end

data/lib/redis_queued_locks/swarm.rb

@@ -62,7 +62,7 @@ class RedisQueuedLocks::Swarm
   def swarm_status
     sync.synchronize do
       {
-        auto_swarm: rql_client.config[:swarm][:auto_swarm],
+        auto_swarm: rql_client.config['swarm.auto_swarm'],
         supervisor: supervisor.status,
         probe_hosts: probe_hosts_element.status,
         flush_zombies: flush_zombies_element.status
@@ -76,23 +76,14 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
-  def swarm_info(zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl])
+  def swarm_info(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
     RedisQueuedLocks::Swarm::Acquirers.acquirers(
       rql_client.redis_client,
       zombie_ttl
     )
   end
 
-  # @return [
-  #   RedisQueuedLocks::Data[
-  #     ok: <Boolean>,
-  #     result: {
-  #       host_id1 <String> => score1 <String>,
-  #       host_id2 <String> => score2 <String>,
-  #       etc...
-  #     }
-  #   ]
-  # ]
+  # @return [Hash<Symbol,Hash[String,Float]]
   #
   # @api public
   # @since 1.9.0
@@ -106,21 +97,14 @@ class RedisQueuedLocks::Swarm
   # @option zombie_ttl [Integer]
   # @option lock_scan_size [Integer]
   # @option queue_scan_size [Integer]
-  # @return [
-  #   RedisQueuedLocks::Data[
-  #     ok: <Boolean>,
-  #     deleted_zombie_hosts: <Set<String>>,
-  #     deleted_zombie_acquiers: <Set<String>>,
-  #     deleted_zombie_locks: <Set<String>>
-  #   ]
-  # ]
+  # @return [Hash<Bool,Set<String>]
   #
   # @api public
   # @since 1.9.0
   def flush_zombies(
-    zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: rql_client.config[:swarm][:flush_zombies][:zombie_lock_scan_size],
-    queue_scan_size: rql_client.config[:swarm][:flush_zombies][:zombie_queue_scan_size]
+    zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size'],
+    queue_scan_size: rql_client.config['swarm.flush_zombies.zombie_queue_scan_size']
   )
     RedisQueuedLocks::Swarm::FlushZombies.flush_zombies(
       rql_client.redis_client,
@@ -137,8 +121,8 @@ class RedisQueuedLocks::Swarm
   # @api public
   # @since 1.9.0
   def zombie_locks(
-    zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: rql_client.config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+    zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_locks(
       rql_client.redis_client,
@@ -153,11 +137,11 @@ class RedisQueuedLocks::Swarm
   #
   # @api ppublic
   # @since 1.9.0
-  def zombie_acquiers(
-    zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: rql_client.config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+  def zombie_acquirers(
+    zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
-    RedisQueuedLocks::Swarm::ZombieInfo.zombie_acquiers(
+    RedisQueuedLocks::Swarm::ZombieInfo.zombie_acquirers(
       rql_client.redis_client,
       zombie_ttl,
       lock_scan_size
@@ -169,24 +153,19 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
-  def zombie_hosts(zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl])
+  def zombie_hosts(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_hosts(rql_client.redis_client, zombie_ttl)
   end
 
   # @option zombie_ttl [Integer]
   # @option lock_sacn_size [Integer]
   # @return [Hash<Symbol,Set<String>>]
-  #   Format: {
-  #     zombie_hosts: <Set<String>>,
-  #     zombie_acquirers: <Set<String>>,
-  #     zombie_locks: <Set<String>>
-  #   }
   #
   # @api public
   # @since 1.9.0
   def zombies_info(
-    zombie_ttl: rql_client.config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: rql_client.config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+    zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
     RedisQueuedLocks::Swarm::ZombieInfo.zombies_info(
       rql_client.redis_client,
@@ -195,7 +174,7 @@ class RedisQueuedLocks::Swarm
     )
   end
 
-  # @return [NilClass,Hash<Symbol,Symbol|Boolean>]
+  # @return [Hash<Symbol,Symbol|Boolean>] Example: { ok: true, result: :swarming }
   #
   # @api public
   # @since 1.9.0
@@ -222,11 +201,11 @@ class RedisQueuedLocks::Swarm
       # NOTE: need to give a little timespot to initialize ractor objects and their main loops;
       sleep(0.1)
 
-      RedisQueuedLocks::Data[ok: true, result: :swarming]
+      { ok: true, result: :swarming }
     end
   end
 
-  # @return [NilClass,Hash<Symbol,Symbol|Boolean>]
+  # @return [Hash<Symbol,Symbol|Boolean>] Example: { ok: true, result: :terminating }
   #
   # @api public
   # @since 1.9.0
@@ -239,7 +218,7 @@ class RedisQueuedLocks::Swarm
       # NOTE: need to give a little timespot to stop ractor objects and their main loops;
       sleep(0.1)
 
-      RedisQueuedLocks::Data[ok: true, result: :terminating]
+      { ok: true, result: :terminating }
     end
   end
 end

data/lib/redis_queued_locks/utilities.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.14.0
 module RedisQueuedLocks::Utilities
   require_relative 'utilities/lock'
 
@@ -44,6 +45,14 @@ module RedisQueuedLocks::Utilities
     yield rescue nil
   end
 
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.14.0
+  def clock_gettime
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+  end
+
   # Possible statuses (at the moment of Ruby@3.4):
   #   - "created"
   #   - "blocking"
@@ -56,7 +65,7 @@ module RedisQueuedLocks::Utilities
   # @api private
   # @since 1.9.0
   def ractor_status(ractor)
-    ractor.to_s.match(RACTOR_STATUS_PATTERN)[:status]
+    ractor.to_s.match(RACTOR_STATUS_PATTERN)[:status] # steep:ignore
   end
 
   # @param ractor [Ractor]
@@ -86,6 +95,6 @@ module RedisQueuedLocks::Utilities
     status = thread.status
     return 'dead' if status == false
     return 'failed' if status == nil
-    status
+    status #: String
   end
 end

data/lib/redis_queued_locks/version.rb

@@ -5,6 +5,6 @@ module RedisQueuedLocks
   #
   # @api public
   # @since 0.0.1
-  # @version 1.12.1
-  VERSION = '1.12.1'
+  # @version 1.14.0
+  VERSION = '1.14.0'
 end

data/lib/redis_queued_locks.rb

@@ -2,10 +2,8 @@
 
 require 'timeout'
 require 'redis-client'
-require 'qonfig'
 require 'securerandom'
 require 'logger'
-require 'objspace'
 
 # @api public
 # @since 1.0.0
@@ -17,10 +15,11 @@ module RedisQueuedLocks
   require_relative 'redis_queued_locks/data'
   require_relative 'redis_queued_locks/debugger'
   require_relative 'redis_queued_locks/resource'
-  require_relative 'redis_queued_locks/acquier'
+  require_relative 'redis_queued_locks/acquirer'
   require_relative 'redis_queued_locks/instrument'
   require_relative 'redis_queued_locks/swarm'
   require_relative 'redis_queued_locks/client'
+  require_relative 'redis_queued_locks/config'
 
   # @since 1.0.0
   extend RedisQueuedLocks::Debugger::Interface

data/rbs_collection.lock.yaml

@@ -0,0 +1,28 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: connection_pool
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 52a7ef8a9328fb2413e3b42dd8ee37deb703a940
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: securerandom
+  version: '0'
+  source:
+    type: stdlib
+- name: timeout
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,17 @@
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+path: .gem_rbs_collection
+
+gems:
+  - name: redis-client
+  - name: securerandom
+  - name: timeout
+  - name: redis-client
+  - name: securerandom
+  - name: logger
+  - name: monitor

data/redis_queued_locks.gemspec

@@ -3,38 +3,38 @@
 require_relative 'lib/redis_queued_locks/version'
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version = '>= 3.1'
+  spec.required_ruby_version = '>= 3.3'
 
-  spec.name    = 'redis_queued_locks'
+  spec.name = 'redis_queued_locks'
   spec.version = RedisQueuedLocks::VERSION
   spec.authors = ['Rustam Ibragimov']
-  spec.email   = ['iamdaiver@gmail.com']
+  spec.email = ['iamdaiver@gmail.com']
 
   spec.summary =
     'Distributed locks with "prioritized lock acquisition queue" ' \
     'capabilities based on the Redis Database.'
 
   spec.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 it\'s 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.'
-
-  spec.homepage    = 'https://github.com/0exp/redis_queued_locks'
-  spec.license     = 'MIT'
-
-  spec.metadata['homepage_uri']    = spec.homepage
+    "|> Distributed locks with \"prioritized lock acquisition queue\" capabilities " \
+    "based on the Redis Database.\n" \
+    "|> Each lock request is put into the request queue " \
+    "(each lock is hosted by it's own queue separately from other queues) and processed " \
+    "in order of their priority (FIFO).\n" \
+    "|> Each lock request lives some period of time (RTTL) " \
+    "(with requeue capabilities) which guarantees the request queue will never be stacked.\n" \
+    "|> 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.\n" \
+    "|> Provides flexible invocation flow, parametrized limits " \
+    "(lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), " \
+    "logging and instrumentation."
+
+  spec.homepage = 'https://github.com/0exp/redis_queued_locks'
+  spec.license = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = "#{spec.homepage}/blob/master"
-  spec.metadata['changelog_uri']   = "#{spec.homepage}/blob/master/CHANGELOG.md"
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
@@ -48,5 +48,4 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'redis-client', '~> 0.20'
-  spec.add_dependency 'qonfig', '~> 0.28'
 end

data/sig/manifest.yml

@@ -0,0 +1,6 @@
+dependencies:
+  - timeout
+  - redis-client
+  - securerandom
+  - logger
+  - monitor

data/sig/redis_queued_locks/acquier.rbs

@@ -0,0 +1,4 @@
+module RedisQueuedLocks
+  module Acquirer
+  end
+end

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

@@ -0,0 +1,9 @@
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module DelayExecution
+        def delay_execution: (Integer retry_delay, Integer retry_jitter) -> Integer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module DequeueFromLockQueue
+        module LogVisitor
+          def self.dequeue_from_lock_queue: (
+            RQL::loggerObj logger,
+            bool log_sampled,
+            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/dequeue_from_lock_queue.rbs

@@ -0,0 +1,26 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module AcquireLock
+      module DequeueFromLockQueue
+        def dequeue_from_lock_queue: (
+          RC::client redis,
+          RQL::loggerObj logger,
+          String lock_key,
+          Symbol read_write_mode,
+          String lock_key_queue,
+          String read_lock_key_queue,
+          String write_lock_key_queue,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy,
+          bool log_sampled,
+          bool instr_sampled
+        ) -> { ok: bool, result: Integer }
+      end
+    end
+  end
+end