MongoDBx::Class::ConnectionPool(3) A simple connection pool for MongoDBx::Class


version 1.030002


# create a MongoDBx::Class object normally:
use MongoDBx::Class;
my $dbx = MongoDBx::Class->new(namespace => 'MyApp::Model::DB');
# instead of connection, create a rotated pool
my $pool = $dbx->pool(max_conns => 200, type => 'rotated'); # max_conns defaults to 100
# or, if you need to pass attributes to MongoDB::Connection->new():
my $pool = $dbx->pool(max_conns => 200, type => 'rotated', params => {
host => $host,
username => $username,
password => $password,
# get a connection from the pool on a per-request basis
my $conn = $pool->get_conn;
# ... do stuff with $conn and return it when done ...
$pool->return_conn($conn); # only relevant on backup pools but a good practice anyway


WARNING: connection pooling via MongoDBx::Class is experimental. It is a quick, simple implementation that may or may not work as expected.

MongoDBx::Class::ConnectionPool is a very simple interface for creating MongoDB connection pools. The basic idea is: create a pool with a maximum number of connections as a setting. Give connections from the pool on a per-request basis. The pool is empty at first, and connections are created for each request, until the maximum is reached. The behaviour of the pool when this maximum is reached is dependent on the implementation. There are currently two implementations:

  • Rotated pools (MongoDBx::Class::ConnectionPool::Rotated) - these pools hold at most the number of maximum connections defined. An index is held, initially starting at zero. When a request for a connection is made, the connection located at the current index is returned (if exists, otherwise a new one is created), and the index is incremented. When the index reaches the end of the pool, it returns to the beginning (i.e. zero), and the next request will receive the first connection in the pool, and so on. This means that every connection in the pool can be shared by an unlimited number of requesters.
  • Backup pools (MongoDBx::Class::ConnectionPool::Backup) - these pools expect the receiver of a connection to return it when they're done using it. If no connections are available when a request is made (i.e. all connections are being used), a backup connection is returned (there can be only one backup connection). This means that every connection in the pool can be used by one requester, except for the backup connection which can be shared.

The rotated pool makes more sense for pools with a relatively low number of connections, while the backup pool is more fit for a larger number of connections. The selection should be based, among other factors, on your application's metrics: how many end-users (e.g. website visitors) use your application concurrently? does your application experience larger loads and usage numbers at certain points of the day/week? does it make more sense for you to balance work between a predefined number of connections (rotated pool) or do you prefer each end-user to get their own connection (backup pool)?

At any rate, every end-user will receive a connection, shared or not.



An integer defining the maximum number of connections a pool can hold. Defaults to 100.


An array-reference of MongoDBx::Class::Connection objects, this is the actual pool. Mostly used and populated internally.


For backup pools, this will be an integer indicating the number of connections from the pool currently being used. For rotated pools, this will be the index of the connection to be given to the next end-user.


A hash-ref of parameters to pass to "MongoDB::Connection->new()" when creating a new connection. See ``ATTRIBUTES'' in MongoDB::Connection for more information.


This Moose role requires consuming classes to implement the following methods:
  • get_conn()

    Returns a connection from the pool to a requester, possibly creating a new one in the process if no connections are available and the maximum has not been reached yet.

  • return_conn( $conn )

    Returns a connection (receievd via "get_conn()") to the pool, meant to be called by the end-user after being done with the connection. Only relevant when "get_conn()" actually takes the connection out of the pool (so it is not shared), like with backup pools. Otherwise this method may do nothing.


Meant to be used by consuming classes:


Creates a new MongoDBx::Class::Connection object, increments the "num_used" attribute, and returns the new connection. Should be used by "get_conn()".

_inc_used( [ $int ] )

Increases the "num_used" attribute by $int (which can be negative), or by 1 if $int is not supplied.

_add_to_pool( $conn )

Adds a connection object to the end of the pool (the "pool" attribute).


Ido Perlmuter, "<ido at>"


Please report any bugs or feature requests to "bug-mongodbx-class at", or through the web interface at <>. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.


You can find documentation for this module with the perldoc command.

        perldoc MongoDBx::Class::ConnectionPool

You can also look for information at:


Copyright 2010-2014 Ido Perlmuter.

This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.

See for more information.