Method: Mongo::Server::ConnectionPool#initialize

Defined in:
lib/mongo/server/connection_pool.rb

#initialize(server, options = {}) ⇒ ConnectionPool

Create the new connection pool.

Note: Additionally, options for connections created by this pool should

be included in the options passed here, and they will be forwarded to
any connections created by the pool.

Parameters:

  • server (Server) —

    The server which this connection pool is for.

  • options (Hash) (defaults to: {}) —

    The connection pool options.

Options Hash (options):

  • :max_size (Integer) —

    The maximum pool size. Setting this option to zero creates an unlimited connection pool.

  • :max_connecting (Integer) —

    The maximum number of connections that can be connecting simultaneously. The default is 2. This option should be increased if there are many threads that share same connection pool and the application is experiencing timeouts while waiting for connections to be established.

  • :max_pool_size (Integer) —

    Deprecated. The maximum pool size. If max_size is also given, max_size and max_pool_size must be identical.

  • :min_size (Integer) —

    The minimum pool size.

  • :min_pool_size (Integer) —

    Deprecated. The minimum pool size. If min_size is also given, min_size and min_pool_size must be identical.

  • :wait_timeout (Float) —

    The time to wait, in seconds, for a free connection.

  • :wait_queue_timeout (Float) —

    Deprecated. Alias for :wait_timeout. If both wait_timeout and wait_queue_timeout are given, their values must be identical.

  • :max_idle_time (Float) —

    The time, in seconds, after which idle connections should be closed by the pool.

  • :populator_io (true, false) —

    For internal driver use only. Set to false to prevent the populator threads from being created and started in the server’s connection pool. It is intended for use in tests that also turn off monitoring_io, unless the populator is explicitly needed. If monitoring_io is off, but the populator_io is on, the populator needs to be manually closed at the end of the test, since a cluster without monitoring is considered not connected, and thus will not clean up the connection pool populator threads on close.

Since:

  • 2.0.0, API changed in 2.9.0



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/mongo/server/connection_pool.rb', line 102

def initialize(server, options = {})
  unless server.is_a?(Server)
    raise ArgumentError, 'First argument must be a Server instance'
  end
  options = options.dup
  if options[:min_size] && options[:min_pool_size] && options[:min_size] != options[:min_pool_size]
    raise ArgumentError, "Min size #{options[:min_size]} is not identical to min pool size #{options[:min_pool_size]}"
  end
  if options[:max_size] && options[:max_pool_size] && options[:max_size] != options[:max_pool_size]
    raise ArgumentError, "Max size #{options[:max_size]} is not identical to max pool size #{options[:max_pool_size]}"
  end
  if options[:wait_timeout] && options[:wait_queue_timeout] && options[:wait_timeout] != options[:wait_queue_timeout]
    raise ArgumentError, "Wait timeout #{options[:wait_timeout]} is not identical to wait queue timeout #{options[:wait_queue_timeout]}"
  end
  options[:min_size] ||= options[:min_pool_size]
  options.delete(:min_pool_size)
  options[:max_size] ||= options[:max_pool_size]
  options.delete(:max_pool_size)
  if options[:min_size] && options[:max_size] &&
    (options[:max_size] != 0 && options[:min_size] > options[:max_size])
  then
    raise ArgumentError, "Cannot have min size #{options[:min_size]} exceed max size #{options[:max_size]}"
  end
  if options[:wait_queue_timeout]
    options[:wait_timeout] ||= options[:wait_queue_timeout]
  end
  options.delete(:wait_queue_timeout)

  @server = server
  @options = options.freeze

  @generation_manager = GenerationManager.new(server: server)
  @ready = false
  @closed = false

  # A connection owned by this pool should be either in the
  # available connections array (which is used as a stack)
  # or in the checked out connections set.
  @available_connections = available_connections = []
  @checked_out_connections = Set.new
  @pending_connections = Set.new
  @interrupt_connections = []

  # Mutex used for synchronizing access to @available_connections and
  # @checked_out_connections. The pool object is thread-safe, thus
  # all methods that retrieve or modify instance variables generally
  # must do so under this lock.
  @lock = Mutex.new

  # Background thread reponsible for maintaining the size of
  # the pool to at least min_size
  @populator = Populator.new(self, options)
  @populate_semaphore = Semaphore.new

  # Condition variable to enforce the first check in check_out: max_pool_size.
  # This condition variable should be signaled when the number of
  # unavailable connections decreases (pending + pending_connections +
  # checked_out_connections).
  @size_cv = Mongo::ConditionVariable.new(@lock)
  # This represents the number of threads that have made it past the size_cv
  # gate but have not acquired a connection to add to the pending_connections
  # set.
  @connection_requests = 0

  # Condition variable to enforce the second check in check_out: max_connecting.
  # Thei condition variable should be signaled when the number of pending
  # connections decreases.
  @max_connecting_cv = Mongo::ConditionVariable.new(@lock)
  @max_connecting = options.fetch(:max_connecting, DEFAULT_MAX_CONNECTING)

  ObjectSpace.define_finalizer(self, self.class.finalize(@available_connections, @pending_connections, @populator))

  publish_cmap_event(
    Monitoring::Event::Cmap::PoolCreated.new(@server.address, options, self)
  )
end