redis-promise 0.1.0

data/sorbet/rbi/gems/connection_pool@3.0.2.rbi

@@ -0,0 +1,340 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `connection_pool` gem.
+# Please instead update this file by running `bin/tapioca gem connection_pool`.
+
+
+# Generic connection pool class for sharing a limited number of objects or network connections
+# among many threads.  Note: pool elements are lazily created.
+#
+# Example usage with block (faster):
+#
+#    @pool = ConnectionPool.new { Redis.new }
+#    @pool.with do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Using optional timeout override (for that single invocation)
+#
+#    @pool.with(timeout: 2.0) do |redis|
+#      redis.lpop('my-list') if redis.llen('my-list') > 0
+#    end
+#
+# Example usage replacing an existing connection (slower):
+#
+#    $redis = ConnectionPool.wrap { Redis.new }
+#
+#    def do_work
+#      $redis.lpop('my-list') if $redis.llen('my-list') > 0
+#    end
+#
+# Accepts the following options:
+# - :size - number of connections to pool, defaults to 5
+# - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
+# - :auto_reload_after_fork - automatically drop all connections after fork, defaults to true
+#
+# pkg:gem/connection_pool#lib/connection_pool/version.rb:1
+class ConnectionPool
+  # pkg:gem/connection_pool#lib/connection_pool.rb:48
+  def initialize(timeout: T.unsafe(nil), size: T.unsafe(nil), auto_reload_after_fork: T.unsafe(nil), name: T.unsafe(nil), &_arg4); end
+
+  # Number of pool entries available for checkout at this instant.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:173
+  def available; end
+
+  # pkg:gem/connection_pool#lib/connection_pool.rb:123
+  def checkin(force: T.unsafe(nil)); end
+
+  # pkg:gem/connection_pool#lib/connection_pool.rb:111
+  def checkout(timeout: T.unsafe(nil), **_arg1); end
+
+  # Marks the current thread's checked-out connection for discard.
+  #
+  # When a connection is marked for discard, it will not be returned to the pool
+  # when checked in. Instead, the connection will be discarded.
+  # This is useful when a connection has become invalid or corrupted
+  # and should not be reused.
+  #
+  # Takes an optional block that will be called with the connection to be discarded.
+  # The block should perform any necessary clean-up on the connection.
+  #
+  # @yield [conn]
+  # @yieldparam conn [Object] The connection to be discarded.
+  # @yieldreturn [void]
+  #
+  #
+  # Note: This only affects the connection currently checked out by the calling thread.
+  # The connection will be discarded when +checkin+ is called.
+  #
+  # @return [void]
+  #
+  # @example
+  #   pool.with do |conn|
+  #     begin
+  #       conn.execute("SELECT 1")
+  #     rescue SomeConnectionError
+  #       pool.discard_current_connection  # Mark connection as bad
+  #       raise
+  #     end
+  #   end
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:107
+  def discard_current_connection(&block); end
+
+  # Number of pool entries created and idle in the pool.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:178
+  def idle; end
+
+  # Reaps idle connections that have been idle for over +idle_seconds+.
+  # +idle_seconds+ defaults to 60.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:168
+  def reap(idle_seconds: T.unsafe(nil), &_arg1); end
+
+  # Reloads the ConnectionPool by passing each connection to +block+ and then
+  # removing it the pool. Subsequent checkouts will create new connections as
+  # needed.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:162
+  def reload(&_arg0); end
+
+  # Shuts down the ConnectionPool by passing each connection to +block+ and
+  # then removing it from the pool. Attempting to checkout a connection after
+  # shutdown will raise +ConnectionPool::PoolShuttingDownError+.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool.rb:154
+  def shutdown(&_arg0); end
+
+  # pkg:gem/connection_pool#lib/connection_pool.rb:46
+  def size; end
+
+  # pkg:gem/connection_pool#lib/connection_pool.rb:75
+  def then(**_arg0); end
+
+  # pkg:gem/connection_pool#lib/connection_pool.rb:60
+  def with(**_arg0); end
+
+  class << self
+    # pkg:gem/connection_pool#lib/connection_pool/fork.rb:6
+    def after_fork; end
+
+    # pkg:gem/connection_pool#lib/connection_pool.rb:42
+    def wrap(**_arg0, &_arg1); end
+  end
+end
+
+# pkg:gem/connection_pool#lib/connection_pool.rb:5
+class ConnectionPool::Error < ::RuntimeError; end
+
+# pkg:gem/connection_pool#lib/connection_pool/fork.rb:21
+module ConnectionPool::ForkTracker
+  # pkg:gem/connection_pool#lib/connection_pool/fork.rb:22
+  def _fork; end
+end
+
+# JRuby, et al
+#
+# pkg:gem/connection_pool#lib/connection_pool/fork.rb:3
+ConnectionPool::INSTANCES = T.let(T.unsafe(nil), ObjectSpace::WeakMap)
+
+# pkg:gem/connection_pool#lib/connection_pool.rb:7
+class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error; end
+
+# The TimedStack manages a pool of homogeneous connections (or any resource
+# you wish to manage). Connections are created lazily up to a given maximum
+# number.
+#
+# Examples:
+#
+#    ts = TimedStack.new(size: 1) { MyConnection.new }
+#
+#    # fetch a connection
+#    conn = ts.pop
+#
+#    # return a connection
+#    ts.push conn
+#
+#    conn = ts.pop
+#    ts.pop timeout: 5
+#    #=> raises ConnectionPool::TimeoutError after 5 seconds
+#
+# pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:19
+class ConnectionPool::TimedStack
+  # Creates a new pool with +size+ connections that are created from the given
+  # +block+.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:25
+  def initialize(size: T.unsafe(nil), &block); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:50
+  def <<(obj, **_arg1); end
+
+  # Reduce the created count
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:143
+  def decrement_created; end
+
+  # Returns +true+ if there are no available connections.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:125
+  def empty?; end
+
+  # The number of connections created and available on the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:137
+  def idle; end
+
+  # The number of connections available on the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:131
+  def length; end
+
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:20
+  def max; end
+
+  # Retrieves a connection from the stack. If a connection is available it is
+  # immediately returned. If no connection is available within the given
+  # timeout a ConnectionPool::TimeoutError is raised.
+  #
+  # @option options [Float] :timeout (0.5) Wait this many seconds for an available entry
+  # @option options [Class] :exception (ConnectionPool::TimeoutError) Exception class to raise
+  #   if an entry was not available within the timeout period. Use `exception: false` to return nil.
+  #
+  # Other options may be used by subclasses that extend TimedStack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:62
+  def pop(timeout: T.unsafe(nil), exception: T.unsafe(nil), **_arg2); end
+
+  # Returns +obj+ to the stack. Additional kwargs are ignored in TimedStack but may be
+  # used by subclasses that extend TimedStack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:38
+  def push(obj, **_arg1); end
+
+  # Reaps connections that were checked in more than +idle_seconds+ ago.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:106
+  def reap(idle_seconds:); end
+
+  # Shuts down the TimedStack by passing each connection to +block+ and then
+  # removing it from the pool. Attempting to checkout a connection after
+  # shutdown will raise +ConnectionPool::PoolShuttingDownError+ unless
+  # +:reload+ is +true+.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:92
+  def shutdown(reload: T.unsafe(nil), &block); end
+
+  private
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must returns true if a connection is available on the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:167
+  def connection_stored?(**_arg0); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:149
+  def current_time; end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return a connection from the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:175
+  def fetch_connection(**_arg0); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # Returns true if the first connection in the stack has been idle for more than idle_seconds
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:209
+  def idle_connections?(idle_seconds); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method returns the oldest idle connection if it has been idle for more than idle_seconds.
+  # This requires that the stack is kept in order of checked in time (oldest first).
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:195
+  def reserve_idle_connection(idle_seconds); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must shut down all connections on the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:183
+  def shutdown_connections(**_arg0); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return +obj+ to the stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:220
+  def store_connection(obj, **_arg1); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must create a connection if and only if the total number of
+  # connections allowed has not been met.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:229
+  def try_create(**_arg0); end
+
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must returns a connection from the stack if one exists. Allows
+  # subclasses with expensive match/search algorithms to avoid double-handling
+  # their stack.
+  #
+  # pkg:gem/connection_pool#lib/connection_pool/timed_stack.rb:159
+  def try_fetch_connection(**_arg0); end
+end
+
+# pkg:gem/connection_pool#lib/connection_pool.rb:9
+class ConnectionPool::TimeoutError < ::Timeout::Error; end
+
+# pkg:gem/connection_pool#lib/connection_pool/version.rb:2
+ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
+
+# pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:2
+class ConnectionPool::Wrapper < ::BasicObject
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:5
+  def initialize(**options, &_arg1); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:37
+  def method_missing(name, *_arg1, **_arg2, &_arg3); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:25
+  def pool_available; end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:17
+  def pool_shutdown(&_arg0); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:21
+  def pool_size; end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:29
+  def respond_to?(id, *_arg1, **_arg2); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:13
+  def with(**_arg0, &_arg1); end
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:9
+  def wrapped_pool; end
+
+  private
+
+  # pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:33
+  def respond_to_missing?(id, *_arg1, **_arg2); end
+end
+
+# pkg:gem/connection_pool#lib/connection_pool/wrapper.rb:3
+ConnectionPool::Wrapper::METHODS = T.let(T.unsafe(nil), Array)
+
+module Process
+  extend ::RedisClient::PIDCache::CoreExt
+  extend ::ConnectionPool::ForkTracker
+end