← Back
Editing: pooling.py
# MySQL Connector/Python - MySQL driver written in Python. # Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved. # MySQL Connector/Python is licensed under the terms of the GPLv2 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most # MySQL Connectors. There are special exceptions to the terms and # conditions of the GPLv2 as it is applied to this software, see the # FOSS License Exception # <http://www.mysql.com/about/legal/licensing/foss-exception.html>. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA """Implementing pooling of connections to MySQL servers. """ import re from uuid import uuid4 # pylint: disable=F0401 try: import queue except ImportError: # Python v2 import Queue as queue # pylint: enable=F0401 import threading from . import errors from .connection import MySQLConnection CONNECTION_POOL_LOCK = threading.RLock() CNX_POOL_MAXSIZE = 32 CNX_POOL_MAXNAMESIZE = 64 CNX_POOL_NAMEREGEX = re.compile(r'[^a-zA-Z0-9._:\-*$#]') def generate_pool_name(**kwargs): """Generate a pool name This function takes keyword arguments, usually the connection arguments for MySQLConnection, and tries to generate a name for a pool. Raises PoolError when no name can be generated. Returns a string. """ parts = [] for key in ('host', 'port', 'user', 'database'): try: parts.append(str(kwargs[key])) except KeyError: pass if not parts: raise errors.PoolError( "Failed generating pool name; specify pool_name") return '_'.join(parts) class PooledMySQLConnection(object): """Class holding a MySQL Connection in a pool PooledMySQLConnection is used by MySQLConnectionPool to return an instance holding a MySQL connection. It works like a MySQLConnection except for methods like close() and config(). The close()-method will add the connection back to the pool rather than disconnecting from the MySQL server. Configuring the connection have to be done through the MySQLConnectionPool method set_config(). Using config() on pooled connection will raise a PoolError. """ def __init__(self, pool, cnx): """Initialize The pool argument must be an instance of MySQLConnectionPoll. cnx if an instance of MySQLConnection. """ if not isinstance(pool, MySQLConnectionPool): raise AttributeError( "pool should be a MySQLConnectionPool") if not isinstance(cnx, MySQLConnection): raise AttributeError( "cnx should be a MySQLConnection") self._cnx_pool = pool self._cnx = cnx def __getattr__(self, attr): """Calls attributes of the MySQLConnection instance""" return getattr(self._cnx, attr) def close(self): """Do not close, but add connection back to pool The close() method does not close the connection with the MySQL server. The connection is added back to the pool so it can be reused. When the pool is configured to reset the session, the session state will be cleared by re-authenticating the user. """ cnx = self._cnx if self._cnx_pool.reset_session: cnx.reset_session() self._cnx_pool.add_connection(cnx) self._cnx = None def config(self, **kwargs): """Configuration is done through the pool""" raise errors.PoolError( "Configuration for pooled connections should " "be done through the pool itself." ) @property def pool_name(self): """Return the name of the connection pool""" return self._cnx_pool.pool_name class MySQLConnectionPool(object): """Class defining a pool of MySQL connections""" def __init__(self, pool_size=5, pool_name=None, pool_reset_session=True, **kwargs): """Initialize Initialize a MySQL connection pool with a maximum number of connections set to pool_size. The rest of the keywords arguments, kwargs, are configuration arguments for MySQLConnection instances. """ self._pool_size = None self._pool_name = None self._reset_session = pool_reset_session self._set_pool_size(pool_size) self._set_pool_name(pool_name or generate_pool_name(**kwargs)) self._cnx_config = {} self._cnx_queue = queue.Queue(self._pool_size) self._config_version = uuid4() if kwargs: self.set_config(**kwargs) cnt = 0 while cnt < self._pool_size: self.add_connection() cnt += 1 @property def pool_name(self): """Return the name of the connection pool""" return self._pool_name @property def pool_size(self): """Return number of connections managed by the pool""" return self._pool_size @property def reset_session(self): """Return whether to reset session""" return self._reset_session def set_config(self, **kwargs): """Set the connection configuration for MySQLConnection instances This method sets the configuration used for creating MySQLConnection instances. See MySQLConnection for valid connection arguments. Raises PoolError when a connection argument is not valid, missing or not supported by MySQLConnection. """ if not kwargs: return with CONNECTION_POOL_LOCK: try: test_cnx = MySQLConnection() test_cnx.config(**kwargs) self._cnx_config = kwargs self._config_version = uuid4() except AttributeError as err: raise errors.PoolError( "Connection configuration not valid: {0}".format(err)) def _set_pool_size(self, pool_size): """Set the size of the pool This method sets the size of the pool but it will not resize the pool. Raises an AttributeError when the pool_size is not valid. Invalid size is 0, negative or higher than pooling.CNX_POOL_MAXSIZE. """ if pool_size <= 0 or pool_size > CNX_POOL_MAXSIZE: raise AttributeError( "Pool size should be higher than 0 and " "lower or equal to {0}".format(CNX_POOL_MAXSIZE)) self._pool_size = pool_size def _set_pool_name(self, pool_name): r"""Set the name of the pool This method checks the validity and sets the name of the pool. Raises an AttributeError when pool_name contains illegal characters ([^a-zA-Z0-9._\-*$#]) or is longer than pooling.CNX_POOL_MAXNAMESIZE. """ if CNX_POOL_NAMEREGEX.search(pool_name): raise AttributeError( "Pool name '{0}' contains illegal characters".format(pool_name)) if len(pool_name) > CNX_POOL_MAXNAMESIZE: raise AttributeError( "Pool name '{0}' is too long".format(pool_name)) self._pool_name = pool_name def _queue_connection(self, cnx): """Put connection back in the queue This method is putting a connection back in the queue. It will not acquire a lock as the methods using _queue_connection() will have it set. Raises PoolError on errors. """ if not isinstance(cnx, MySQLConnection): raise errors.PoolError( "Connection instance not subclass of MySQLConnection.") try: self._cnx_queue.put(cnx, block=False) except queue.Full: errors.PoolError("Failed adding connection; queue is full") def add_connection(self, cnx=None): """Add a connection to the pool This method instantiates a MySQLConnection using the configuration passed when initializing the MySQLConnectionPool instance or using the set_config() method. If cnx is a MySQLConnection instance, it will be added to the queue. Raises PoolError when no configuration is set, when no more connection can be added (maximum reached) or when the connection can not be instantiated. """ with CONNECTION_POOL_LOCK: if not self._cnx_config: raise errors.PoolError( "Connection configuration not available") if self._cnx_queue.full(): raise errors.PoolError( "Failed adding connection; queue is full") if not cnx: cnx = MySQLConnection(**self._cnx_config) try: if (self._reset_session and self._cnx_config['compress'] and cnx.get_server_version() < (5, 7, 3)): raise errors.NotSupportedError("Pool reset session is " "not supported with " "compression for MySQL " "server version 5.7.2 " "or earlier.") except KeyError: pass # pylint: disable=W0201,W0212 cnx._pool_config_version = self._config_version # pylint: enable=W0201,W0212 else: if not isinstance(cnx, MySQLConnection): raise errors.PoolError( "Connection instance not subclass of MySQLConnection.") self._queue_connection(cnx) def get_connection(self): """Get a connection from the pool This method returns an PooledMySQLConnection instance which has a reference to the pool that created it, and the next available MySQL connection. When the MySQL connection is not connect, a reconnect is attempted. Raises PoolError on errors. Returns a PooledMySQLConnection instance. """ with CONNECTION_POOL_LOCK: try: cnx = self._cnx_queue.get(block=False) except queue.Empty: raise errors.PoolError( "Failed getting connection; pool exhausted") # pylint: disable=W0201,W0212 if not cnx.is_connected() \ or self._config_version != cnx._pool_config_version: cnx.config(**self._cnx_config) try: cnx.reconnect() except errors.InterfaceError: # Failed to reconnect, give connection back to pool self._queue_connection(cnx) raise cnx._pool_config_version = self._config_version # pylint: enable=W0201,W0212 return PooledMySQLConnection(self, cnx) def _remove_connections(self): """Close all connections This method closes all connections. It returns the number of connections it closed. Used mostly for tests. Returns int. """ with CONNECTION_POOL_LOCK: cnt = 0 cnxq = self._cnx_queue while cnxq.qsize(): try: cnx = cnxq.get(block=False) cnx.disconnect() cnt += 1 except queue.Empty: return cnt except errors.PoolError: raise except errors.Error: # Any other error when closing means connection is closed pass return cnt
Save File
Cancel