class Bundler::ConnectionPool - bundler: Ruby Standard Library Documentation

# class Bundler::ConnectionPool

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

### Constants

DEFAULTS
INSTANCES
VERSION

### Attributes

auto_reload_after_fork[R]

Automatically drop all connections after fork

size[R]

Size of this connection pool

### Public Class Methods

after_fork() click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 52
    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

new(options = {}, &block) click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 90
    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"
      INSTANCES[self] = self if INSTANCES
    end

wrap(options, &block) click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 44
    def self.wrap(options, &block)
      Wrapper.new(options, &block)
    end

### Public Instance Methods

available() click to toggle source

Number of pool entries available for checkout at this instant.

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 169
    def available
      @available.length
    end

checkin(force: false) click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 129
    def checkin(force: false)
      if ::Thread.current[@key]
        if ::Thread.current[@key_count] == 1 || force
          @available.push(::Thread.current[@key])
          ::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

checkout(options = {}) click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 119
    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)
      end
    end

reload(&block) click to toggle source

Reloads the `Bundler::ConnectionPool` by passing each connection to `block` and then removing it the pool. Subsequent checkouts will create new connections as needed.

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 159
    def reload(&block)
      @available.shutdown(reload: true, &block)
    end

shutdown(&block) click to toggle source

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`.

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 150
    def shutdown(&block)
      @available.shutdown(&block)
    end

then(options = {})
Alias for: with
with(options = {}) { |conn| ... } click to toggle source

    # File bundler/vendor/connection_pool/lib/connection_pool.rb, line 105
    def with(options = {})
      Thread.handle_interrupt(Exception => :never) do
        conn = checkout(options)
        begin
          Thread.handle_interrupt(Exception => :immediate) do
            yield conn
          end
        ensure
          checkin
        end
      end
    end

Also aliased as: then