# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Core SQLAlchemy connectivity routines. """ import itertools import logging import os import re import time import debtcollector.renames import six import sqlalchemy from sqlalchemy import event from sqlalchemy import exc from sqlalchemy import pool from sqlalchemy.sql.expression import select from oslo_db import exception from oslo_db.sqlalchemy import exc_filters from oslo_db.sqlalchemy import ndb from oslo_db.sqlalchemy import utils LOG = logging.getLogger(__name__) def _thread_yield(dbapi_con, con_record): """Ensure other greenthreads get a chance to be executed. If we use eventlet.monkey_patch(), eventlet.greenthread.sleep(0) will execute instead of time.sleep(0). Force a context switch. With common database backends (eg MySQLdb and sqlite), there is no implicit yield caused by network I/O since they are implemented by C libraries that eventlet cannot monkey patch. """ time.sleep(0) def _connect_ping_listener(connection, branch): """Ping the server at connection startup. Ping the server at transaction begin and transparently reconnect if a disconnect exception occurs. """ if branch: return # turn off "close with result". This can also be accomplished # by branching the connection, however just setting the flag is # more performant and also doesn't get involved with some # connection-invalidation awkardness that occurs (see # https://bitbucket.org/zzzeek/sqlalchemy/issue/3215/) save_should_close_with_result = connection.should_close_with_result connection.should_close_with_result = False try: # run a SELECT 1. use a core select() so that # any details like that needed by Oracle, DB2 etc. are handled. connection.scalar(select([1])) except exception.DBConnectionError: # catch DBConnectionError, which is raised by the filter # system. # disconnect detected. The connection is now # "invalid", but the pool should be ready to return # new connections assuming they are good now. # run the select again to re-validate the Connection. LOG.exception( 'Database connection was found disconnected; reconnecting') connection.scalar(select([1])) finally: connection.should_close_with_result = save_should_close_with_result def _setup_logging(connection_debug=0): """setup_logging function maps SQL debug level to Python log level. Connection_debug is a verbosity of SQL debugging information. 0=None(default value), 1=Processed only messages with WARNING level or higher 50=Processed only messages with INFO level or higher 100=Processed only messages with DEBUG level """ if connection_debug >= 0: logger = logging.getLogger('sqlalchemy.engine') if connection_debug == 100: logger.setLevel(logging.DEBUG) elif connection_debug >= 50: logger.setLevel(logging.INFO) else: logger.setLevel(logging.WARNING) def _extend_url_parameters(url, connection_parameters): for key, value in six.moves.urllib.parse.parse_qs( connection_parameters).items(): if key in url.query: existing = url.query[key] if not isinstance(existing, list): url.query[key] = existing = utils.to_list(existing) existing.extend(value) value = existing else: url.query[key] = value if len(value) == 1: url.query[key] = value[0] def _vet_url(url): if "+" not in url.drivername and not url.drivername.startswith("sqlite"): if url.drivername.startswith("mysql"): LOG.warning( "URL %r does not contain a '+drivername' portion, " "and will make use of a default driver. " "A full dbname+drivername:// protocol is recommended. " "For MySQL, it is strongly recommended that mysql+pymysql:// " "be specified for maximum service compatibility", url ) else: LOG.warning( "URL %r does not contain a '+drivername' portion, " "and will make use of a default driver. " "A full dbname+drivername:// protocol is recommended.", url ) @debtcollector.renames.renamed_kwarg( "idle_timeout", "connection_recycle_time", replace=True) def create_engine(sql_connection, sqlite_fk=False, mysql_sql_mode=None, mysql_enable_ndb=False, connection_recycle_time=3600, connection_debug=0, max_pool_size=None, max_overflow=None, pool_timeout=None, sqlite_synchronous=True, connection_trace=False, max_retries=10, retry_interval=10, thread_checkin=True, logging_name=None, json_serializer=None, json_deserializer=None, connection_parameters=None): """Return a new SQLAlchemy engine.""" url = sqlalchemy.engine.url.make_url(sql_connection) if connection_parameters: _extend_url_parameters(url, connection_parameters) _vet_url(url) engine_args = { "pool_recycle": connection_recycle_time, 'connect_args': {}, 'logging_name': logging_name } _setup_logging(connection_debug) _init_connection_args( url, engine_args, max_pool_size=max_pool_size, max_overflow=max_overflow, pool_timeout=pool_timeout, json_serializer=json_serializer, json_deserializer=json_deserializer, ) engine = sqlalchemy.create_engine(url, **engine_args) if mysql_enable_ndb: ndb.enable_ndb_support(engine) _init_events( engine, mysql_sql_mode=mysql_sql_mode, sqlite_synchronous=sqlite_synchronous, sqlite_fk=sqlite_fk, thread_checkin=thread_checkin, connection_trace=connection_trace ) # register alternate exception handler exc_filters.register_engine(engine) # register engine connect handler event.listen(engine, "engine_connect", _connect_ping_listener) # initial connect + test # NOTE(viktors): the current implementation of _test_connection() # does nothing, if max_retries == 0, so we can skip it if max_retries: test_conn = _test_connection(engine, max_retries, retry_interval) test_conn.close() return engine @utils.dispatch_for_dialect('*', multiple=True) def _init_connection_args( url, engine_args, max_pool_size=None, max_overflow=None, pool_timeout=None, **kw): pool_class = url.get_dialect().get_pool_class(url) if issubclass(pool_class, pool.QueuePool): if max_pool_size is not None: engine_args['pool_size'] = max_pool_size if max_overflow is not None: engine_args['max_overflow'] = max_overflow if pool_timeout is not None: engine_args['pool_timeout'] = pool_timeout @_init_connection_args.dispatch_for("sqlite") def _init_connection_args(url, engine_args, **kw): pool_class = url.get_dialect().get_pool_class(url) # singletonthreadpool is used for :memory: connections; # replace it with StaticPool. if issubclass(pool_class, pool.SingletonThreadPool): engine_args["poolclass"] = pool.StaticPool engine_args['connect_args']['check_same_thread'] = False @_init_connection_args.dispatch_for("postgresql") def _init_connection_args(url, engine_args, **kw): if 'client_encoding' not in url.query: # Set encoding using engine_args instead of connect_args since # it's supported for PostgreSQL 8.*. More details at: # http://docs.sqlalchemy.org/en/rel_0_9/dialects/postgresql.html engine_args['client_encoding'] = 'utf8' engine_args['json_serializer'] = kw.get('json_serializer') engine_args['json_deserializer'] = kw.get('json_deserializer') @_init_connection_args.dispatch_for("mysql") def _init_connection_args(url, engine_args, **kw): if 'charset' not in url.query: engine_args['connect_args']['charset'] = 'utf8' @_init_connection_args.dispatch_for("mysql+mysqlconnector") def _init_connection_args(url, engine_args, **kw): # mysqlconnector engine (<1.0) incorrectly defaults to # raise_on_warnings=True # https://bitbucket.org/zzzeek/sqlalchemy/issue/2515 if 'raise_on_warnings' not in url.query: engine_args['connect_args']['raise_on_warnings'] = False @_init_connection_args.dispatch_for("mysql+mysqldb") @_init_connection_args.dispatch_for("mysql+oursql") def _init_connection_args(url, engine_args, **kw): # Those drivers require use_unicode=0 to avoid performance drop due # to internal usage of Python unicode objects in the driver # http://docs.sqlalchemy.org/en/rel_0_9/dialects/mysql.html if 'use_unicode' not in url.query: if six.PY3: engine_args['connect_args']['use_unicode'] = 1 else: engine_args['connect_args']['use_unicode'] = 0 @utils.dispatch_for_dialect('*', multiple=True) def _init_events(engine, thread_checkin=True, connection_trace=False, **kw): """Set up event listeners for all database backends.""" _add_process_guards(engine) if connection_trace: _add_trace_comments(engine) if thread_checkin: sqlalchemy.event.listen(engine, 'checkin', _thread_yield) @_init_events.dispatch_for("mysql") def _init_events(engine, mysql_sql_mode=None, **kw): """Set up event listeners for MySQL.""" if mysql_sql_mode is not None: @sqlalchemy.event.listens_for(engine, "connect") def _set_session_sql_mode(dbapi_con, connection_rec): cursor = dbapi_con.cursor() cursor.execute("SET SESSION sql_mode = %s", [mysql_sql_mode]) @sqlalchemy.event.listens_for(engine, "first_connect") def _check_effective_sql_mode(dbapi_con, connection_rec): if mysql_sql_mode is not None: _set_session_sql_mode(dbapi_con, connection_rec) cursor = dbapi_con.cursor() cursor.execute("SHOW VARIABLES LIKE 'sql_mode'") realmode = cursor.fetchone() if realmode is None: LOG.warning('Unable to detect effective SQL mode') else: realmode = realmode[1] LOG.debug('MySQL server mode set to %s', realmode) if 'TRADITIONAL' not in realmode.upper() and \ 'STRICT_ALL_TABLES' not in realmode.upper(): LOG.warning( "MySQL SQL mode is '%s', " "consider enabling TRADITIONAL or STRICT_ALL_TABLES", realmode) if ndb.ndb_status(engine): ndb.init_ndb_events(engine) @_init_events.dispatch_for("sqlite") def _init_events(engine, sqlite_synchronous=True, sqlite_fk=False, **kw): """Set up event listeners for SQLite. This includes several settings made on connections as they are created, as well as transactional control extensions. """ def regexp(expr, item): reg = re.compile(expr) return reg.search(six.text_type(item)) is not None @sqlalchemy.event.listens_for(engine, "connect") def _sqlite_connect_events(dbapi_con, con_record): # Add REGEXP functionality on SQLite connections dbapi_con.create_function('regexp', 2, regexp) if not sqlite_synchronous: # Switch sqlite connections to non-synchronous mode dbapi_con.execute("PRAGMA synchronous = OFF") # Disable pysqlite's emitting of the BEGIN statement entirely. # Also stops it from emitting COMMIT before any DDL. # below, we emit BEGIN ourselves. # see http://docs.sqlalchemy.org/en/rel_0_9/dialects/\ # sqlite.html#serializable-isolation-savepoints-transactional-ddl dbapi_con.isolation_level = None if sqlite_fk: # Ensures that the foreign key constraints are enforced in SQLite. dbapi_con.execute('pragma foreign_keys=ON') @sqlalchemy.event.listens_for(engine, "begin") def _sqlite_emit_begin(conn): # emit our own BEGIN, checking for existing # transactional state if 'in_transaction' not in conn.info: conn.execute("BEGIN") conn.info['in_transaction'] = True @sqlalchemy.event.listens_for(engine, "rollback") @sqlalchemy.event.listens_for(engine, "commit") def _sqlite_end_transaction(conn): # remove transactional marker conn.info.pop('in_transaction', None) def _test_connection(engine, max_retries, retry_interval): if max_retries == -1: attempts = itertools.count() else: attempts = six.moves.range(max_retries) # See: http://legacy.python.org/dev/peps/pep-3110/#semantic-changes for # why we are not using 'de' directly (it can be removed from the local # scope). de_ref = None for attempt in attempts: try: return engine.connect() except exception.DBConnectionError as de: msg = 'SQL connection failed. %s attempts left.' LOG.warning(msg, max_retries - attempt) time.sleep(retry_interval) de_ref = de else: if de_ref is not None: six.reraise(type(de_ref), de_ref) def _add_process_guards(engine): """Add multiprocessing guards. Forces a connection to be reconnected if it is detected as having been shared to a sub-process. """ @sqlalchemy.event.listens_for(engine, "connect") def connect(dbapi_connection, connection_record): connection_record.info['pid'] = os.getpid() @sqlalchemy.event.listens_for(engine, "checkout") def checkout(dbapi_connection, connection_record, connection_proxy): pid = os.getpid() if connection_record.info['pid'] != pid: LOG.debug( "Parent process %(orig)s forked (%(newproc)s) with an open " "database connection, " "which is being discarded and recreated.", {"newproc": pid, "orig": connection_record.info['pid']}) connection_record.connection = connection_proxy.connection = None raise exc.DisconnectionError( "Connection record belongs to pid %s, " "attempting to check out in pid %s" % (connection_record.info['pid'], pid) ) def _add_trace_comments(engine): """Add trace comments. Augment statements with a trace of the immediate calling code for a given statement. """ import os import sys import traceback target_paths = set([ os.path.dirname(sys.modules['oslo_db'].__file__), os.path.dirname(sys.modules['sqlalchemy'].__file__) ]) try: skip_paths = set([ os.path.dirname(sys.modules['oslo_db.tests'].__file__), ]) except KeyError: skip_paths = set() @sqlalchemy.event.listens_for(engine, "before_cursor_execute", retval=True) def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): # NOTE(zzzeek) - if different steps per DB dialect are desirable # here, switch out on engine.name for now. stack = traceback.extract_stack() our_line = None for idx, (filename, line, method, function) in enumerate(stack): for tgt in skip_paths: if filename.startswith(tgt): break else: for tgt in target_paths: if filename.startswith(tgt): our_line = idx break if our_line: break if our_line: trace = "; ".join( "File: %s (%s) %s" % ( line[0], line[1], line[2] ) # include three lines of context. for line in stack[our_line - 3:our_line] ) statement = "%s -- %s" % (statement, trace) return statement, parameters