class Sequel::ShardedTimedQueueConnectionPool

A connection pool allowing multi-threaded access to a sharded pool of connections, using a timed queue (only available in Ruby 3.2+).

Attributes

max_size[R]

The maximum number of connections this pool will create per shard.

Public Class Methods

new(db, opts = OPTS) click to toggle source

The following additional options are respected:

:max_connections: The maximum number of connections the connection pool will open (default 4)
:pool_timeout: The amount of seconds to wait to acquire a connection before raising a PoolTimeout (default 5)
:servers: A hash of servers to use. Keys should be symbols. If not present, will use a single :default server.
:servers_hash: The base hash to use for the servers. By default, Sequel uses Hash.new(:default). You can use a hash with a default proc that raises an error if you want to catch all cases where a nonexistent server is used.

Calls superclass method Sequel::ConnectionPool::new

   # File lib/sequel/connection_pool/sharded_timed_queue.rb
24 def initialize(db, opts = OPTS)
25   super
26 
27   @max_size = Integer(opts[:max_connections] || 4)
28   raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
29   @mutex = Mutex.new  
30   @timeout = Float(opts[:pool_timeout] || 5)
31 
32   @allocated = {}
33   @sizes = {}
34   @queues = {}
35   @servers = opts.fetch(:servers_hash, Hash.new(:default))
36 
37   add_servers([:default])
38   add_servers(opts[:servers].keys) if opts[:servers]
39 end

Public Instance Methods

add_servers(servers) click to toggle source

Adds new servers to the connection pool. Allows for dynamic expansion of the potential replicas/shards at runtime. servers argument should be an array of symbols.

   # File lib/sequel/connection_pool/sharded_timed_queue.rb
43 def add_servers(servers)
44   sync do
45     servers.each do |server|
46       next if @servers.has_key?(server)
47 
48       @servers[server] = server
49       @sizes[server] = 0
50       @queues[server] = Queue.new
51       (@allocated[server] = {}).compare_by_identity
52     end
53   end
54   nil
55 end

all_connections() { |conn| ... } click to toggle source

Yield all of the available connections, and the one currently allocated to this thread (if one is allocated). This will not yield connections currently allocated to other threads, as it is not safe to operate on them.

   # File lib/sequel/connection_pool/sharded_timed_queue.rb
60 def all_connections
61   thread = Sequel.current
62   sync{@queues.to_a}.each do |server, queue|
63     if conn = owned_connection(thread, server)
64       yield conn
65     end
66 
67     # Use a hash to record all connections already seen.  As soon as we
68     # come across a connection we've already seen, we stop the loop.
69     conns = {}
70     conns.compare_by_identity
71     while true
72       conn = nil
73       begin
74         break unless (conn = queue.pop(timeout: 0)) && !conns[conn]
75         conns[conn] = true
76         yield conn
77       ensure
78         queue.push(conn) if conn
79       end
80     end
81   end
82 
83   nil
84 end

disconnect(opts=OPTS) click to toggle source

Removes all connections currently in the pool’s queue. This method has the effect of disconnecting from the database, assuming that no connections are currently being used.

Once a connection is requested using hold, the connection pool creates new connections to the database.

If the :server option is provided, it should be a symbol or array of symbols, and then the method will only disconnect connectsion from those specified shards.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
 95 def disconnect(opts=OPTS)
 96   (opts[:server] ? Array(opts[:server]) : sync{@servers.keys}).each do |server|
 97     raise Sequel::Error, "invalid server" unless queue = sync{@queues[server]}
 98     while conn = queue.pop(timeout: 0)
 99       disconnect_pool_connection(conn, server)
100     end
101     fill_queue(server)
102   end
103   nil
104 end

hold(server=:default) { |conn| ... } click to toggle source

Chooses the first available connection for the given server, or if none are available, creates a new connection. Passes the connection to the supplied block:

pool.hold(:server1) {|conn| conn.execute('DROP TABLE posts')}

Pool#hold is re-entrant, meaning it can be called recursively in the same thread without blocking.

If no connection is immediately available and the pool is already using the maximum number of connections, Pool#hold will block until a connection is available or the timeout expires. If the timeout expires before a connection can be acquired, a Sequel::PoolTimeout is raised.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
119 def hold(server=:default)
120   server = pick_server(server)
121   t = Sequel.current
122   if conn = owned_connection(t, server)
123     return yield(conn)
124   end
125 
126   begin
127     conn = acquire(t, server)
128     yield conn
129   rescue Sequel::DatabaseDisconnectError, *@error_classes => e
130     if disconnect_error?(e)
131       oconn = conn
132       conn = nil
133       disconnect_pool_connection(oconn, server) if oconn
134       sync{@allocated[server].delete(t)}
135       fill_queue(server)
136     end
137     raise
138   ensure
139     release(t, conn, server) if conn
140   end
141 end

num_waiting(server=:default) click to toggle source

The number of threads waiting to check out a connection for the given server.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
145 def num_waiting(server=:default)
146   @queues[pick_server(server)].num_waiting
147 end

pool_type() click to toggle source

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
196 def pool_type
197   :sharded_timed_queue
198 end

remove_servers(servers) click to toggle source

Remove servers from the connection pool. Similar to disconnecting from all given servers, except that after it is used, future requests for the servers will use the :default server instead.

Note that an error will be raised if there are any connections currently checked out for the given servers.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
160 def remove_servers(servers)
161   conns = []
162   raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
163 
164   sync do
165     servers.each do |server|
166       next unless @servers.has_key?(server)
167 
168       queue = @queues[server]
169 
170       while conn = queue.pop(timeout: 0)
171         @sizes[server] -= 1
172         conns << conn
173       end
174 
175       unless @sizes[server] == 0
176         raise Sequel::Error, "cannot remove server #{server} as it has allocated connections"
177       end
178 
179       @servers.delete(server)
180       @sizes.delete(server)
181       @queues.delete(server)
182       @allocated.delete(server)
183     end
184   end
185 
186   nil
187 ensure
188   disconnect_connections(conns)
189 end

servers() click to toggle source

Return an array of symbols for servers in the connection pool.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
192 def servers
193   sync{@servers.keys}
194 end

size(server=:default) click to toggle source

The total number of connections in the pool. Using a non-existant server will return nil.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
150 def size(server=:default)
151   sync{@sizes[server]}
152 end

Private Instance Methods

acquire(thread, server) click to toggle source

Assigns a connection to the supplied thread, if one is available.

This should return a connection if one is available within the timeout, or raise PoolTimeout if a connection could not be acquired within the timeout.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
312 def acquire(thread, server)
313   queue = sync{@queues[server]}
314   if conn = queue.pop(timeout: 0) || try_make_new(server) || queue.pop(timeout: @timeout)
315     sync{@allocated[server][thread] = conn}
316   else
317     name = db.opts[:name]
318     raise ::Sequel::PoolTimeout, "timeout: #{@timeout}, server: #{server}#{", database name: #{name}" if name}"
319   end
320 end

can_make_new?(server, current_size) click to toggle source

Whether the given size is less than the maximum size of the pool. In that case, the pool’s current size is incremented. If this method returns true, space in the pool for the connection is preallocated, and preallocated_make_new should be called to create the connection.

Calling code should have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
265 def can_make_new?(server, current_size)
266   if @max_size > current_size
267     @sizes[server] += 1
268   end
269 end

checkin_connection(conn, server) click to toggle source

Adds a connection to the queue of available connections, returns the connection.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
369 def checkin_connection(conn, server)
370   sync{@queues[server]}.push(conn)
371   conn
372 end

disconnect_connections(conns) click to toggle source

Disconnect all available connections immediately, and schedule currently allocated connections for disconnection as soon as they are returned to the pool. The calling code should NOT have the mutex before calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
224 def disconnect_connections(conns)
225   conns.each{|conn| disconnect_connection(conn)}
226 end

disconnect_pool_connection(conn, server) click to toggle source

Decrement the current size of the pool for the server when disconnecting connections.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
231 def disconnect_pool_connection(conn, server)
232   sync{@sizes[server] -= 1}
233   disconnect_connection(conn)
234 end

fill_queue(server) click to toggle source

If there are any threads waiting on the queue, try to create new connections in a separate thread if the pool is not yet at the maximum size.

The reason for this method is to handle cases where acquire could not retrieve a connection immediately, and the pool was already at the maximum size. In that case, the acquire will wait on the queue until the timeout. This method is called after disconnecting to potentially add new connections to the pool, so the threads that are currently waiting for connections do not timeout after the pool is no longer full.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
247 def fill_queue(server)
248   queue = sync{@queues[server]}
249   if queue.num_waiting > 0
250     Thread.new do
251       while queue.num_waiting > 0 && (conn = try_make_new(server))
252         queue.push(conn)
253       end
254     end
255   end
256 end

owned_connection(thread, server) click to toggle source

Returns the connection owned by the supplied thread for the given server, if any. The calling code should NOT already have the mutex before calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
324 def owned_connection(thread, server)
325   sync{@allocated[server][thread]}
326 end

pick_server(server) click to toggle source

If the server given is in the hash, return it, otherwise, return the default server.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
329 def pick_server(server)
330   sync{@servers[server]}
331 end

preallocated_make_new(server) click to toggle source

Create a new connection, after the pool’s current size has already been updated to account for the new connection. If there is an exception when creating the connection, decrement the current size.

This should only be called after can_make_new?. If there is an exception between when can_make_new? is called and when preallocated_make_new is called, it has the effect of reducing the maximum size of the connection pool by 1, since the current size of the pool will show a higher number than the number of connections allocated or in the queue.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
214 def preallocated_make_new(server)
215   make_new(server)
216 rescue Exception
217   sync{@sizes[server] -= 1}
218   raise
219 end

preconnect(concurrent = false) click to toggle source

Create the maximum number of connections immediately. This should not be called with a true argument unless no code is currently operating on the database.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
337 def preconnect(concurrent = false)
338   conn_servers = sync{@servers.keys}.map!{|s| Array.new(@max_size - @sizes[s], s)}.flatten!
339 
340   if concurrent
341     conn_servers.map! do |server|
342       queue = sync{@queues[server]}
343       Thread.new do 
344         if conn = try_make_new(server)
345           queue.push(conn)
346         end
347       end
348     end.each(&:value)
349   else
350     conn_servers.each do |server|
351       if conn = try_make_new(server)
352         sync{@queues[server]}.push(conn)
353       end
354     end
355   end
356 
357   nil
358 end

release(thread, _, server) click to toggle source

Releases the connection assigned to the supplied thread back to the pool.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
363 def release(thread, _, server)
364   checkin_connection(sync{@allocated[server].delete(thread)}, server)
365   nil
366 end

sync() { || ... } click to toggle source

Yield to the block while inside the mutex.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
377 def sync
378   @mutex.synchronize{yield}
379 end

try_make_new(server) click to toggle source

Try to make a new connection if there is space in the pool. If the pool is already full, look for dead threads/fibers and disconnect the related connections.

Calling code should not have the mutex when calling this.

    # File lib/sequel/connection_pool/sharded_timed_queue.rb
276 def try_make_new(server)
277   return preallocated_make_new(server) if sync{can_make_new?(server, @sizes[server])}
278 
279   to_disconnect = nil
280   do_make_new = false
281 
282   sync do
283     current_size = @sizes[server]
284     alloc = @allocated[server]
285     alloc.keys.each do |t|
286       unless t.alive?
287         (to_disconnect ||= []) << alloc.delete(t)
288         current_size -= 1
289       end
290     end
291   
292     do_make_new = true if can_make_new?(server, current_size)
293   end
294 
295   begin
296     preallocated_make_new(server) if do_make_new
297   ensure
298     if to_disconnect
299       to_disconnect.each{|conn| disconnect_pool_connection(conn, server)}
300       fill_queue(server)
301     end
302   end
303 end