Class: Bundler::ConnectionPool::TimedStack

Inherits:
Object
  • Object
show all
Defined in:
lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb

Overview

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(size = 0, &block) ⇒ TimedStack

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



27
28
29
30
31
32
33
34
35
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 27

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

Instance Attribute Details

#max ⇒ Object (readonly)

Returns the value of attribute max.



21
22
23
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 21

def max
  @max
end

Instance Method Details

#empty? ⇒ Boolean

Returns true if there are no available connections.

Returns:

  • (Boolean) 


125
126
127
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 125

def empty?
  (@created - @que.length) >= @max
end

#idle ⇒ Object

The number of connections created and available on the stack.



138
139
140
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 138

def idle
  @que.length
end

#length ⇒ Object

The number of connections available on the stack.



132
133
134
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 132

def length
  @max - @created + @que.length
end

#pop(timeout = 0.5, options = {}) ⇒ Object

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.

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



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 64

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
      return fetch_connection(options) if connection_stored?(options)

      connection = try_create(options)
      return connection if connection

      to_wait = deadline - current_time
      raise Bundler::ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available" if to_wait <= 0
      @resource.wait(@mutex, to_wait)
    end
  end
end

#push(obj, options = {}) ⇒ Object Also known as: <<

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



41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 41

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

#reap(idle_seconds, &block) ⇒ Object

Reaps connections that were checked in more than idle_seconds ago.

Raises:

  • (ArgumentError) 


104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 104

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

#shutdown(reload: false, &block) ⇒ Object

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.

Raises:

  • (ArgumentError) 


90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb', line 90

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