bundler 4.0.23 → 4.1.0.beta1

data/lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb

@@ -1,237 +0,0 @@
-##
-# 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(1) { MyConnection.new }
-#
-#    # fetch a connection
-#    conn = ts.pop
-#
-#    # return a connection
-#    ts.push conn
-#
-#    conn = ts.pop
-#    ts.pop timeout: 5
-#    #=> raises Bundler::ConnectionPool::TimeoutError after 5 seconds
-class Bundler::ConnectionPool::TimedStack
-  attr_reader :max
-
-  ##
-  # Creates a new pool with +size+ connections that are created from the given
-  # +block+.
-  def initialize(size = 0, &block)
-    @create_block = block
-    @created = 0
-    @que = []
-    @max = size
-    @mutex = Thread::Mutex.new
-    @resource = Thread::ConditionVariable.new
-    @shutdown_block = nil
-  end
-
-  ##
-  # Returns +obj+ to the stack. +options+ is ignored in TimedStack but may be
-  # used by subclasses that extend TimedStack.
-  def push(obj, options = {})
-    @mutex.synchronize do
-      if @shutdown_block
-        @created -= 1 unless @created == 0
-        @shutdown_block.call(obj)
-      else
-        store_connection obj, options
-      end
-
-      @resource.broadcast
-    end
-  end
-  alias_method :<<, :push
-
-  ##
-  # 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 Bundler::ConnectionPool::TimeoutError is raised.
-  #
-  # @option options [Float] :timeout (0.5) Wait this many seconds for an available entry
-  # @option options [Class] :exception (Bundler::ConnectionPool::TimeoutError) Exception class to raise
-  #   if an entry was not available within the timeout period. Use `exception: false` to return nil.
-  #
-  # The +timeout+ argument will be removed in 3.0.
-  # Other options may be used by subclasses that extend TimedStack.
-  def pop(timeout = 0.5, options = {})
-    options, timeout = timeout, 0.5 if Hash === timeout
-    timeout = options.fetch :timeout, timeout
-
-    deadline = current_time + timeout
-    @mutex.synchronize do
-      loop do
-        raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
-        if (conn = try_fetch_connection(options))
-          return conn
-        end
-
-        connection = try_create(options)
-        return connection if connection
-
-        to_wait = deadline - current_time
-        if to_wait <= 0
-          exc = options.fetch(:exception, Bundler::ConnectionPool::TimeoutError)
-          if exc
-            raise Bundler::ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available"
-          else
-            return nil
-          end
-        end
-        @resource.wait(@mutex, to_wait)
-      end
-    end
-  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 +Bundler::ConnectionPool::PoolShuttingDownError+ unless
-  # +:reload+ is +true+.
-  def shutdown(reload: false, &block)
-    raise ArgumentError, "shutdown must receive a block" unless block
-
-    @mutex.synchronize do
-      @shutdown_block = block
-      @resource.broadcast
-
-      shutdown_connections
-      @shutdown_block = nil if reload
-    end
-  end
-
-  ##
-  # Reaps connections that were checked in more than +idle_seconds+ ago.
-  def reap(idle_seconds, &block)
-    raise ArgumentError, "reap must receive a block" unless block
-    raise ArgumentError, "idle_seconds must be a number" unless idle_seconds.is_a?(Numeric)
-    raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
-
-    idle.times do
-      conn =
-        @mutex.synchronize do
-          raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
-
-          reserve_idle_connection(idle_seconds)
-        end
-      break unless conn
-
-      block.call(conn)
-    end
-  end
-
-  ##
-  # Returns +true+ if there are no available connections.
-  def empty?
-    (@created - @que.length) >= @max
-  end
-
-  ##
-  # The number of connections available on the stack.
-  def length
-    @max - @created + @que.length
-  end
-
-  ##
-  # The number of connections created and available on the stack.
-  def idle
-    @que.length
-  end
-
-  ##
-  # Reduce the created count
-  def decrement_created
-    @created -= 1 unless @created == 0
-  end
-
-  private
-
-  def current_time
-    Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  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.
-  def try_fetch_connection(options = nil)
-    connection_stored?(options) && fetch_connection(options)
-  end
-
-  ##
-  # 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.
-  def connection_stored?(options = nil)
-    !@que.empty?
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must return a connection from the stack.
-  def fetch_connection(options = nil)
-    @que.pop&.first
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must shut down all connections on the stack.
-  def shutdown_connections(options = nil)
-    while (conn = try_fetch_connection(options))
-      @created -= 1 unless @created == 0
-      @shutdown_block.call(conn)
-    end
-  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).
-  def reserve_idle_connection(idle_seconds)
-    return unless idle_connections?(idle_seconds)
-
-    @created -= 1 unless @created == 0
-
-    @que.shift.first
-  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
-  def idle_connections?(idle_seconds)
-    connection_stored? && (current_time - @que.first.last > idle_seconds)
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must return +obj+ to the stack.
-  def store_connection(obj, options = nil)
-    @que.push [obj, current_time]
-  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.
-  def try_create(options = nil)
-    unless @created == @max
-      object = @create_block.call
-      @created += 1
-      object
-    end
-  end
-end

data/lib/bundler/vendor/connection_pool/lib/connection_pool/version.rb

@@ -1,3 +0,0 @@
-class Bundler::ConnectionPool
-  VERSION = "2.5.5"
-end

data/lib/bundler/vendor/connection_pool/lib/connection_pool/wrapper.rb

@@ -1,56 +0,0 @@
-class Bundler::ConnectionPool
-  class Wrapper < ::BasicObject
-    METHODS = [:with, :pool_shutdown, :wrapped_pool]
-
-    def initialize(options = {}, &block)
-      @pool = options.fetch(:pool) { ::Bundler::ConnectionPool.new(options, &block) }
-    end
-
-    def wrapped_pool
-      @pool
-    end
-
-    def with(&block)
-      @pool.with(&block)
-    end
-
-    def pool_shutdown(&block)
-      @pool.shutdown(&block)
-    end
-
-    def pool_size
-      @pool.size
-    end
-
-    def pool_available
-      @pool.available
-    end
-
-    def respond_to?(id, *args)
-      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
-    end
-
-    # rubocop:disable Style/MissingRespondToMissing
-    if ::RUBY_VERSION >= "3.0.0"
-      def method_missing(name, *args, **kwargs, &block)
-        with do |connection|
-          connection.send(name, *args, **kwargs, &block)
-        end
-      end
-    elsif ::RUBY_VERSION >= "2.7.0"
-      ruby2_keywords def method_missing(name, *args, &block)
-        with do |connection|
-          connection.send(name, *args, &block)
-        end
-      end
-    else
-      def method_missing(name, *args, &block)
-        with do |connection|
-          connection.send(name, *args, &block)
-        end
-      end
-    end
-    # rubocop:enable Style/MethodMissingSuper
-    # rubocop:enable Style/MissingRespondToMissing
-  end
-end

data/lib/bundler/vendor/connection_pool/lib/connection_pool.rb

@@ -1,233 +0,0 @@
-require_relative "../../../vendored_timeout"
-require_relative "connection_pool/version"
-
-class Bundler::ConnectionPool
-  class Error < ::RuntimeError; end
-
-  class PoolShuttingDownError < ::Bundler::ConnectionPool::Error; end
-
-  class TimeoutError < ::Gem::Timeout::Error; end
-end
-
-# 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 = Bundler::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 = Bundler::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
-#
-class Bundler::ConnectionPool
-  DEFAULTS = {size: 5, timeout: 5, auto_reload_after_fork: true}.freeze
-
-  def self.wrap(options, &block)
-    Wrapper.new(options, &block)
-  end
-
-  if Process.respond_to?(:fork)
-    INSTANCES = ObjectSpace::WeakMap.new
-    private_constant :INSTANCES
-
-    def self.after_fork
-      INSTANCES.values.each do |pool|
-        next unless pool.auto_reload_after_fork
-
-        # We're on after fork, so we know all other threads are dead.
-        # All we need to do is to ensure the main thread doesn't have a
-        # checked out connection
-        pool.checkin(force: true)
-        pool.reload do |connection|
-          # Unfortunately we don't know what method to call to close the connection,
-          # so we try the most common one.
-          connection.close if connection.respond_to?(:close)
-        end
-      end
-      nil
-    end
-
-    if ::Process.respond_to?(:_fork) # MRI 3.1+
-      module ForkTracker
-        def _fork
-          pid = super
-          if pid == 0
-            Bundler::ConnectionPool.after_fork
-          end
-          pid
-        end
-      end
-      Process.singleton_class.prepend(ForkTracker)
-    end
-  else
-    INSTANCES = nil
-    private_constant :INSTANCES
-
-    def self.after_fork
-      # noop
-    end
-  end
-
-  def initialize(options = {}, &block)
-    raise ArgumentError, "Connection pool requires a block" unless block
-
-    options = DEFAULTS.merge(options)
-
-    @size = Integer(options.fetch(:size))
-    @timeout = options.fetch(:timeout)
-    @auto_reload_after_fork = options.fetch(:auto_reload_after_fork)
-
-    @available = TimedStack.new(@size, &block)
-    @key = :"pool-#{@available.object_id}"
-    @key_count = :"pool-#{@available.object_id}-count"
-    @discard_key = :"pool-#{@available.object_id}-discard"
-    INSTANCES[self] = self if @auto_reload_after_fork && INSTANCES
-  end
-
-  def with(options = {})
-    # We need to manage exception handling manually here in order
-    # to work correctly with `Gem::Timeout.timeout` and `Thread#raise`.
-    # Otherwise an interrupted Thread can leak connections.
-    Thread.handle_interrupt(Exception => :never) do
-      conn = checkout(options)
-      begin
-        Thread.handle_interrupt(Exception => :immediate) do
-          yield conn
-        end
-      ensure
-        checkin
-      end
-    end
-  end
-  alias_method :then, :with
-
-  ##
-  # 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
-  def discard_current_connection(&block)
-    ::Thread.current[@discard_key] = block || proc { |conn| conn }
-  end
-
-  def checkout(options = {})
-    if ::Thread.current[@key]
-      ::Thread.current[@key_count] += 1
-      ::Thread.current[@key]
-    else
-      ::Thread.current[@key_count] = 1
-      ::Thread.current[@key] = @available.pop(options[:timeout] || @timeout, options)
-    end
-  end
-
-  def checkin(force: false)
-    if ::Thread.current[@key]
-      if ::Thread.current[@key_count] == 1 || force
-        if ::Thread.current[@discard_key]
-          begin
-            @available.decrement_created
-            ::Thread.current[@discard_key].call(::Thread.current[@key])
-          rescue
-            nil
-          ensure
-            ::Thread.current[@discard_key] = nil
-          end
-        else
-          @available.push(::Thread.current[@key])
-        end
-        ::Thread.current[@key] = nil
-        ::Thread.current[@key_count] = nil
-      else
-        ::Thread.current[@key_count] -= 1
-      end
-    elsif !force
-      raise Bundler::ConnectionPool::Error, "no connections are checked out"
-    end
-
-    nil
-  end
-
-  ##
-  # Shuts down the Bundler::ConnectionPool by passing each connection to +block+ and
-  # then removing it from the pool. Attempting to checkout a connection after
-  # shutdown will raise +Bundler::ConnectionPool::PoolShuttingDownError+.
-  def shutdown(&block)
-    @available.shutdown(&block)
-  end
-
-  ##
-  # Reloads the Bundler::ConnectionPool by passing each connection to +block+ and then
-  # removing it the pool. Subsequent checkouts will create new connections as
-  # needed.
-  def reload(&block)
-    @available.shutdown(reload: true, &block)
-  end
-
-  ## Reaps idle connections that have been idle for over +idle_seconds+.
-  # +idle_seconds+ defaults to 60.
-  def reap(idle_seconds = 60, &block)
-    @available.reap(idle_seconds, &block)
-  end
-
-  # Size of this connection pool
-  attr_reader :size
-  # Automatically drop all connections after fork
-  attr_reader :auto_reload_after_fork
-
-  # Number of pool entries available for checkout at this instant.
-  def available
-    @available.length
-  end
-
-  # Number of pool entries created and idle in the pool.
-  def idle
-    @available.idle
-  end
-end
-
-require_relative "connection_pool/timed_stack"
-require_relative "connection_pool/wrapper"

data/lib/bundler/vendor/net-http-persistent/README.rdoc

@@ -1,82 +0,0 @@
-= net-http-persistent
-
-home :: https://github.com/drbrain/net-http-persistent
-rdoc :: https://rubydoc.info/gems/net-http-persistent
-
-== DESCRIPTION:
-
-Manages persistent connections using Net::HTTP including a thread pool for
-connecting to multiple hosts.
-
-Using persistent HTTP connections can dramatically increase the speed of HTTP.
-Creating a new HTTP connection for every request involves an extra TCP
-round-trip and causes TCP congestion avoidance negotiation to start over.
-
-Net::HTTP supports persistent connections with some API methods but does not
-make setting up a single persistent connection or managing multiple
-connections easy.  Net::HTTP::Persistent wraps Net::HTTP and allows you to
-focus on how to make HTTP requests.
-
-== FEATURES/PROBLEMS:
-
-* Supports TLS with secure defaults
-* Thread-safe
-* Pure ruby
-
-== SYNOPSIS
-
-The following example will make two requests to the same server.  The
-connection is kept alive between requests:
-
-    require 'net/http/persistent'
-
-    uri = URI 'http://example.com/awesome/web/service'
-
-    http = Net::HTTP::Persistent.new name: 'my_app_name'
-
-    # perform a GET
-    response = http.request uri
-
-    # create a POST
-    post_uri = uri + 'create'
-    post = Net::HTTP::Post.new post_uri.path
-    post.set_form_data 'some' => 'cool data'
-
-    # perform the POST, the URI is always required
-    response = http.request post_uri, post
-
-    # if you are done making http requests, or won't make requests for several
-    # minutes
-    http.shutdown
-
-Please see the documentation on Net::HTTP::Persistent for more information,
-including SSL connection verification, header handling and tunable options.
-
-== INSTALL:
-
-  gem install net-http-persistent
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) Eric Hodel, Aaron Patterson
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/bundler/vendor/net-http-persistent/lib/net/http/persistent/connection.rb

@@ -1,41 +0,0 @@
-##
-# A Gem::Net::HTTP connection wrapper that holds extra information for managing the
-# connection's lifetime.
-
-class Gem::Net::HTTP::Persistent::Connection # :nodoc:
-
-  attr_accessor :http
-
-  attr_accessor :last_use
-
-  attr_accessor :requests
-
-  attr_accessor :ssl_generation
-
-  def initialize http_class, http_args, ssl_generation
-    @http           = http_class.new(*http_args)
-    @ssl_generation = ssl_generation
-
-    reset
-  end
-
-  def finish
-    @http.finish
-  rescue IOError
-  ensure
-    reset
-  end
-  alias_method :close, :finish
-
-  def reset
-    @last_use = Gem::Net::HTTP::Persistent::EPOCH
-    @requests = 0
-  end
-
-  def ressl ssl_generation
-    @ssl_generation = ssl_generation
-
-    finish
-  end
-
-end