redis_queued_locks 1.12.0 → 1.13.0

data/sig/redis_queued_locks/acquirer/release_all_locks.rbs

@@ -0,0 +1,30 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ReleaseAllLocks
+      extend RQL::Utilities
+
+      type releaseResult = { ok: bool, result: { rel_key_cnt: Integer, rel_time: Integer|Float } }
+      def self.release_all_locks: (
+        RC::client redis,
+        Integer batch_size,
+        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
+      ) -> releaseResult
+
+      type fullRelesaeResult = { ok: bool, result: { rel_key_cnt: Integer } }
+      private def self.fully_release_all_locks: (RC::client redis, Integer batch_size) -> fullRelesaeResult
+    end
+  end
+end

data/sig/redis_queued_locks/acquirer/release_lock.rbs

@@ -0,0 +1,38 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  module Acquirer
+    module ReleaseLock
+      extend RQL::Utilities
+
+      type releaseResult = {
+        ok: bool,
+        result: {
+          rel_time: Integer|Float,
+          rel_key: String,
+          rel_queue: String,
+          queue_res: Symbol,
+          lock_res: Symbol
+        }
+      }
+      def self.release_lock: (
+        RC::client redis,
+        String lock_name,
+        RQL::instrObj instrumenter,
+        RQL::loggerObj logger,
+        bool log_sampling_enabled,
+        Integer log_samplingPercent,
+        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
+      ) -> releaseResult
+
+      type fullReleaseResult = { ok: bool, result: { queue: Symbol, lock: Symbol } }
+      private def self.fully_release_lock: (RC::client redis, String lock_key, String lock_key_queue) -> fullReleaseResult
+    end
+  end
+end

data/sig/redis_queued_locks/client.rbs

@@ -0,0 +1,195 @@
+use RedisQueuedLocks as RQL
+use RedisClient as RC
+
+module RedisQueuedLocks
+  class Client
+    @config: RQL::Config
+    @redis_client: RC::client
+    @uniq_identity: String
+    @swarm: RQL::Swarm
+
+    attr_reader config: RQL::Config
+    attr_reader redis_client: RC::client
+    attr_accessor uniq_identity: String
+    attr_reader swarm: RQL::Swarm
+
+    def initialize: (RC::client redis_client) ?{ (RQL::Config) -> void } -> void
+    def configure: () ?{ (RQL::Config) -> void } -> void
+
+    def swarmize!: () -> RQL::Swarm::swarmizeResult
+    def deswarmize!: () -> RQL::Swarm::deswarmizeResult
+    def swarm_info: (?zombie_ttl: Integer) -> RQL::Swarm::Acquirers::acquirersList
+
+    def swarm_status: () -> RQL::Swarm::swarmStatus
+    alias swarm_state swarm_status
+
+    def probe_hosts: () -> RQL::Swarm::ProbeHosts::livingHosts
+    def flush_zombies: (?zombie_ttl: Integer, ?lock_scan_size: Integer, ?queue_scan_size: Integer) -> RQL::Swarm::FlushZombies::flushedZombies
+    def zombie_locks: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieLocks
+    def zombie_acquirers: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieAcquirers
+    def zombie_hosts: (?zombie_ttl: Integer) -> RQL::Swarm::ZombieInfo::zombieHosts
+
+    def zombies_info: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieInfo
+    alias zombies zombies_info
+
+    def lock: (
+      String lock_name,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?raise_errors: bool,
+      ?fail_fast: bool,
+      ?conflict_strategy: Symbol,
+      ?read_write_mode: Symbol,
+      ?access_strategy: Symbol,
+      ?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::AcquireLock::acquireResult
+
+    def lock!: (
+      String lock_name,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?fail_fast: bool,
+      ?conflict_strategy: Symbol,
+      ?read_write_mode: Symbol,
+      ?access_strategy: Symbol,
+      ?identity: String,
+      ?instrumenter: RQL::instrObj,
+      ?meta: Hash[String|Symbol,untyped]?,
+      ?detailed_acq_timeout_error: bool,
+      ?logger: RQL::loggerObj,
+      ?log_lock_try: bool,
+      ?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::AcquireLock::acquireResult
+
+    def unlock: (
+      String lock_name,
+      ?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::ReleaseLock::releaseResult
+    alias release_lock unlock
+
+    def locked?: (String lock_name) -> bool
+    def queued?: (String lock_name) -> bool
+    def lock_info: (String lock_name) -> RQL::Acquirer::LockInfo::lockInfo?
+    def queue_info: (String lock_name) -> RQL::Acquirer::QueueInfo::queueInfo?
+
+    def current_acquirer_id: (
+      ?process_id: Integer|String,
+      ?thread_id: Integer|String,
+      ?fiber_id: Integer|String,
+      ?ractor_id: Integer|String,
+      ?identity: String
+    ) -> String
+
+    def current_host_id: (
+      ?process_id: Integer|String,
+      ?thread_id: Integer|String,
+      ?ractor_id: Integer|String,
+      ?identity: String
+    ) -> String
+
+    def possible_host_ids: (?String identity) -> Array[String]
+
+    def extend_lock_ttl: (
+      String lock_name,
+      Integer milliseconds,
+      ?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::ExtendLockTTL::extendResult
+
+    def clear_locks: (
+      ?batch_size: 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::ReleaseAllLocks::releaseResult
+    alias release_locks clear_locks
+
+    def locks: (?scan_size: Integer, ?with_info: bool) -> RQL::Acquirer::Locks::locks
+             | (?scan_size: Integer, ?with_info: true) -> RQL::Acquirer::Locks::locksInfo
+             | (?scan_size: Integer, ?with_info: false) -> RQL::Acquirer::Locks::lockList
+
+    def locks_info: (?scan_size: Integer) -> RQL::Acquirer::Locks::locksInfo
+
+    def queues: (?scan_size: Integer, ?with_info: bool) -> RQL::Acquirer::Queues::queues
+              | (?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 keys: (?scan_size: Integer) -> RQL::Acquirer::Keys::keyList
+
+    def clear_dead_requests: (
+      ?dead_ttl: Integer,
+      ?scan_size: 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::ClearDeadRequests::clearResult
+  end
+end

data/sig/redis_queued_locks/config/dsl.rbs

@@ -0,0 +1,26 @@
+module RedisQueuedLocks
+  class Config
+    module DSL
+      type configSetters = Hash[String,Proc]
+      type configValidators = Hash[String,Proc]
+
+      module ClassMethods
+        @config_setters: configSetters
+        @config_validators: configValidators
+
+        def config_setters: () -> configSetters
+        def config_validators: () -> configValidators
+
+        def validate: (String config_key) { (String) -> bool } -> void
+        def setting: (String config_key, untyped config_value) -> void
+      end
+
+      module InstanceMethods
+        def config_setters: () -> configSetters
+        def config_validators: () -> configValidators
+      end
+
+      def self.included: (Class child_klass) -> void
+    end
+  end
+end

data/sig/redis_queued_locks/config.rbs

@@ -0,0 +1,23 @@
+module RedisQueuedLocks
+  class Config
+    include RedisQueuedLocks::Config::DSL
+    include RedisQueuedLocks::Config::DSL::InstanceMethods
+    extend RedisQueuedLocks::Config::DSL::ClassMethods
+
+    type configState = Hash[String,untyped]
+
+    @config_state: configState
+    attr_reader config_state: configState
+
+    def initialize: () ?{ (RedisQueuedLocks::Config) -> void } -> void
+    def configure: () ?{ (RedisQueuedLocks::Config) -> void } -> void
+    def []: (String config_key) -> untyped
+    def []=: (String config_key, untyped config_value) -> void
+    def slice: (String config_key_pattern) -> configState
+
+    private
+
+    def prevent_key__non_existent: (String config_key) -> void
+    def prevent_key__invalid_type: (String config_key, untyped config_value) -> void
+  end
+end

data/sig/redis_queued_locks/data.rbs

@@ -0,0 +1,4 @@
+module RedisQueuedLocks
+  class Data < Hash[untyped,untyped]
+  end
+end

data/sig/redis_queued_locks/debugger/interface.rbs

@@ -0,0 +1,9 @@
+module RedisQueuedLocks
+  module Debugger
+    module Interface
+      def debug: (::String message) -> void
+      def enable_debugger!: () -> void
+      def disable_debugger!: () -> void
+    end
+  end
+end

data/sig/redis_queued_locks/debugger.rbs

@@ -0,0 +1,13 @@
+module RedisQueuedLocks
+  module Debugger
+    DEBUG_ENABLED_METHOD: String
+    DEBUG_DISABLED_MEHTOD: String
+
+    self.@enabled: bool
+
+    def self.enable!: () -> void
+    def self.disable!: () -> void
+    def self.enabled?: () -> bool
+    def self.debug: (String message) -> void
+  end
+end

data/sig/redis_queued_locks/errors.rbs

@@ -0,0 +1,43 @@
+module RedisQueuedLocks
+  class Error < ::StandardError
+  end
+
+  class ArgumentError < ::ArgumentError
+  end
+
+  class LockAlreadyObtainedError < Error
+  end
+
+  class LockAcquirementIntermediateTimeoutError < ::Timeout::Error
+  end
+
+  class LockAcquirementTimeoutError < Error
+  end
+
+  class LockAcquirementRetryLimitError < Error
+  end
+
+  class TimedLockIntermediateTimeoutError < ::Timeout::Error
+  end
+
+  class TimedLockTimeoutError < Error
+  end
+
+  class ConflictLockObtainError < Error
+  end
+
+  class SwarmError < Error
+  end
+
+  class SwarmArgumentError < ArgumentError
+  end
+
+  class ConfigError < Error
+  end
+
+  class ConfigNotFoundError < ConfigError
+  end
+
+  class ConfigValidationError < ConfigError
+  end
+end

data/sig/redis_queued_locks/instrument/active_support.rbs

@@ -0,0 +1,7 @@
+module RedisQueuedLocks
+  module Instrument
+    module ActiveSupport
+      def self.notify: (String event, ?Hash[untyped,untyped] payload) -> void
+    end
+  end
+end

data/sig/redis_queued_locks/instrument/sampler.rbs

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

data/sig/redis_queued_locks/instrument/void_notifier.rbs

@@ -0,0 +1,7 @@
+module RedisQueuedLocks
+  module Instrument
+    module VoidNotifier
+      def self.notify: (String event, ?Hash[untyped,untyped] payload) -> void
+    end
+  end
+end

data/sig/redis_queued_locks/instrument.rbs

@@ -0,0 +1,15 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Instrument
+    interface _Sampler
+      def sampling_happened?: (Integer sampling_percent) -> bool
+    end
+
+    type samplerObj = Object & _Sampler
+
+    def self.should_instrument?: (bool instr_sampling_enabled, bool instr_sample_this, Integer instr_sampling_percent, samplerObj instr_sampler) -> bool
+    def self.valid_sampler?: (untyped sampler) -> bool
+    def self.valid_interface?: (untyped instrumenter) -> bool
+  end
+end

data/sig/redis_queued_locks/logging/sampler.rbs

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

data/sig/redis_queued_locks/logging/void_logger.rbs

@@ -0,0 +1,15 @@
+module RedisQueuedLocks
+  module Logging
+    module VoidLogger
+      def self.warn: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.unknown: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.log: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.info: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.error: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.fatal: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.debug: (?untyped? progname) { (?) -> untyped } -> nil
+      def self.add: (?untyped? severity, ?untyped? message, ?untyped? progname) { (?) -> untyped } -> nil
+      def self.<<: (untyped message) -> nil
+    end
+  end
+end

data/sig/redis_queued_locks/logging.rbs

@@ -0,0 +1,15 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  module Logging
+    interface _Sampler
+      def sampling_happened?: (Integer sampling_percent) -> bool
+    end
+
+    type samplerObj = Object & _Sampler
+
+    def self.should_log?: (bool log_sampling_enabled, bool log_sample_this, Integer log_sampling_percent, samplerObj log_sampler) -> bool
+    def self.valid_sampler?: (untyped sampler) -> bool
+    def self.valid_interface?: (untyped logger) -> bool
+  end
+end

data/sig/redis_queued_locks/resource.rbs

@@ -0,0 +1,42 @@
+module RedisQueuedLocks
+  module Resource
+    KEY_PATTERN: String
+    LOCK_PATTERN: String
+    LOCK_QUEUE_PATTERN: String
+    READ_LOCK_QUEUE_PATTERN: String
+    WRITE_LOCK_QUEUE_PATTERN: String
+    SWARM_KEY: String
+    REDIS_TIMESHIFT_ERROR: Integer
+
+    def self.calc_uniq_identity: () -> String
+    def self.acquirer_identifier: (
+      Integer|String process_id,
+      Integer|String thread_id,
+      Integer|String fiber_id,
+      Integer|String ractor_id,
+      String identity
+    ) -> String
+
+    def self.host_identifier: (
+      Integer|String process_id,
+      Integer|String thread_id,
+      Integer|string ractor_id,
+      String identity
+    ) -> String
+
+    def self.prepare_lock_key: (String lock_name) -> String
+    def self.prepare_lock_queue: (String lock_name) -> String
+    def self.prepare_read_lock_queue: (String lock_name) -> String
+    def self.prepare_write_lock_queue: (String lock_name) -> String
+    def self.calc_initial_acquirer_position: () -> Float
+    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.get_thread_id: () -> Integer
+    def self.get_fiber_id: () -> Integer
+    def self.get_ractor_id: () -> Integer
+    def self.get_process_id: () -> Integer
+    def self.possible_host_identifiers: (String identity) -> Array[String]
+  end
+end

data/sig/redis_queued_locks/swarm/acquirers.rbs

@@ -0,0 +1,10 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  class Swarm
+    module Acquirers
+      type acquirersList = Hash[String,{ zombie: bool, last_probe_time: Time, last_probe_score: Float }]
+      def self.acquirers: (RC::client redis_client, Integer zombie_ttl) -> acquirersList
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/flush_zombies.rbs

@@ -0,0 +1,13 @@
+use RedisClient as RC
+
+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 enabled?: () -> bool
+      def swarm!: () -> void
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/probe_hosts.rbs

@@ -0,0 +1,13 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  class Swarm
+    class ProbeHosts < SwarmElement::Threaded
+      type livingHosts = { ok: bool, result: Hash[String,Float] }
+      def self.probe_hosts: (RC::client redis_client, String uniq_identity) -> livingHosts
+
+      def enabled?: () -> bool
+      def spawn_main_loop!: () -> Thread
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/redis_client_builder.rbs

@@ -0,0 +1,19 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  class Swarm
+    module RedisClientBuilder
+      def self.build: (
+        ?pooled: bool,
+        ?sentinel: bool,
+        ?config: Hash[untyped,untyped],
+        ?pool_config: Hash[untyped,untyped]
+      ) -> RC::client
+
+      private def self.sentinel_config: (Hash[Symbol,untyped] config) -> RC::SentinelConfig
+      private def self.non_sentinel_config: (Hash[Symbol,untyped] config) -> RC::Config
+      private def self.pooled_client: (RC::config redis_config, Hash[Symbol,untyped] pool_config) -> RedisClient::Pooled
+      private def self.non_pooled_client: (RC::config redis_config) -> RedisClient
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/supervisor.rbs

@@ -0,0 +1,26 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    class Supervisor
+      include RQL::Utilities
+
+      @rql_client: RQL::Client
+      @visor: Thread?
+      @observable: Proc?
+
+      attr_reader rql_client: RQL::Client
+      attr_reader visor: Thread?
+      attr_reader observable: Proc?
+
+      def initialize: (RQL::Client rql_client) -> void
+
+      type supervisorStatus = { running: bool, state: String, observable: String }
+      def status: () -> supervisorStatus
+
+      def observe!: () { (?) -> untyped } -> void
+      def running?: () -> bool
+      def stop!: () -> void
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/swarm_element/isolated.rbs

@@ -0,0 +1,52 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    module SwarmElement
+      class Isolated
+        include RQL::Utilities
+
+        @rql_client: RQL::Client
+        @swarm_element: Ractor?
+        @sync: RQL::Utilities::Lock
+
+        attr_reader rql_client: RQL::Client
+        attr_reader swarm_element: Ractor?
+        attr_reader sync: RQL::Utilities::Lock
+
+        def initialize: (RQL::Client rql_client) -> void
+        def try_swarm!: () -> void
+        def reswarm_if_dead!: () -> void
+        def try_kill!: () -> void
+        def enabled?: () -> bool
+
+        type elementStatus = {
+          enabled: bool,
+          ractor: { running: bool, state: String },
+          main_loop: { running: bool, state: String }
+        }
+        def status: () -> elementStatus
+
+        def self.swarm_loop: () { () -> Thread } -> void
+
+        private
+
+        def swarm!: () -> void
+        def idle?: () -> bool
+        def swarmed?: () -> bool
+        def swarmed__alive?: () -> bool
+        def swarmed__dead?: () -> bool
+        def swarmed__running?: () -> bool
+        def swarmed__stopped?: () -> bool
+        def swarm_loop__is_active: () -> bool
+
+        type swarmLoopStatus = { main_loop: { alive: bool, state: String } }
+        def swarm_loop__status: () -> swarmLoopStatus?
+
+        def swarm_loop__start: () -> void
+        def swarm_loop__pause: () -> void
+        def swarm_loop__kill: () -> void
+      end
+    end
+  end
+end