# class Bundler::ConnectionPool::TimedStack

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 Timeout::Error after 5 seconds

### Attributes

max[R]

### Public Class Methods

new(size = 0, &block) click to toggle source

Creates a new pool with `size` connections that are created from the given `block`.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 37
    def initialize(size = 0, &block)
      @create_block = block
      @created = 0
      @que = []
      @max = size
      @mutex = Mutex.new
      @resource = ConditionVariable.new
      @shutdown_block = nil
    end

### Public Instance Methods

<<(obj, options = {})
Alias for: push
empty?() click to toggle source

Returns `true` if there are no available connections.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 111
    def empty?
      (@created - @que.length) >= @max
    end

length() click to toggle source

The number of connections available on the stack.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 118
    def length
      @max - @created + @que.length
    end

pop(timeout = 0.5, options = {}) click to toggle source

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 `Timeout::Error` is raised.

`:timeout` is the only checked entry in `options` and is preferred over the `timeout` argument (which will be removed in a future release). Other options may be used by subclasses that extend `TimedStack`.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 73
    def pop(timeout = 0.5, options = {})
      options, timeout = timeout, 0.5 if Hash === timeout
      timeout = options.fetch :timeout, timeout

      deadline = Bundler::ConnectionPool.monotonic_time + timeout
      @mutex.synchronize do
        loop do
          raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
          return fetch_connection(options) if connection_stored?(options)

          connection = try_create(options)
          return connection if connection

          to_wait = deadline - Bundler::ConnectionPool.monotonic_time
          raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
          @resource.wait(@mutex, to_wait)
        end
      end
    end

push(obj, options = {}) click to toggle source

Returns `obj` to the stack. `options` is ignored in `TimedStack` but may be used by subclasses that extend `TimedStack`.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 51
    def push(obj, options = {})
      @mutex.synchronize do
        if @shutdown_block
          @shutdown_block.call(obj)
        else
          store_connection obj, options
        end

        @resource.broadcast
      end
    end

Also aliased as: <<
shutdown(&block) click to toggle source

Shuts down the `TimedStack` which prevents connections from being checked out. The `block` is called once for each connection on the stack.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 97
    def shutdown(&block)
      raise ArgumentError, "shutdown must receive a block" unless block_given?

      @mutex.synchronize do
        @shutdown_block = block
        @resource.broadcast

        shutdown_connections
      end
    end

### Private Instance Methods

connection_stored?(options = nil) click to toggle source

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.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 129
    def connection_stored?(options = nil)
      !@que.empty?
    end

fetch_connection(options = nil) click to toggle source

This is an extension point for `TimedStack` and is called with a mutex.

This method must return a connection from the stack.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 138
    def fetch_connection(options = nil)
      @que.pop
    end

shutdown_connections(options = nil) click to toggle source

This is an extension point for `TimedStack` and is called with a mutex.

This method must shut down all connections on the stack.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 147
    def shutdown_connections(options = nil)
      while connection_stored?(options)
        conn = fetch_connection(options)
        @shutdown_block.call(conn)
      end
    end

store_connection(obj, options = nil) click to toggle source

This is an extension point for `TimedStack` and is called with a mutex.

This method must return `obj` to the stack.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 159
    def store_connection(obj, options = nil)
      @que.push obj
    end

try_create(options = nil) click to toggle source

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.

    # File lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb, line 169
    def try_create(options = nil)
      unless @created == @max
        object = @create_block.call
        @created += 1
        object
      end
    end