def _get_facade():
global _facade
if not _facade:
_facade = db_session.EngineFacade(
cfg.CONF.database.connection,
sqlite_fk=True,
autocommit=False,
**dict(six.iteritems(cfg.CONF.database)))
return _facade
def __init__(self, url):
# Set max_retries to 0, since oslo.db in certain cases may attempt
# to retry making the db connection retried max_retries ^ 2 times
# in failure case and db reconnection has already been implemented
# in storage.__init__.get_connection_from_config function
options = dict(cfg.CONF.database.items())
options['max_retries'] = 0
# oslo.db doesn't support options defined by Ceilometer
for opt in storage.OPTS:
options.pop(opt.name, None)
self._engine_facade = db_session.EngineFacade(url, **options)
def test_drop_dup_entries_in_file_conn(self):
table_name = "__test_tmp_table__"
tmp_db_file = self.create_tempfiles([['name', '']], ext='.sql')[0]
in_file_engine = session.EngineFacade(
'sqlite:///%s' % tmp_db_file).get_engine()
meta = MetaData()
meta.bind = in_file_engine
test_table, values = self._populate_db_for_drop_duplicate_entries(
in_file_engine, meta, table_name)
utils.drop_old_duplicate_entries_from_table(
in_file_engine, table_name, False, 'b', 'c')
def __init__(self, url):
# Set max_retries to 0, since oslo.db in certain cases may attempt
# to retry making the db connection retried max_retries ^ 2 times
# in failure case and db reconnection has already been implemented
# in storage.__init__.get_connection_from_config function
options = dict(cfg.CONF.database.items())
options['max_retries'] = 0
self._engine_facade = db_session.EngineFacade(url, **options)
if self._engine_facade.get_engine().name == 'sqlite':
self.isolation_level = 'SERIALIZABLE'
else:
self.isolation_level = 'REPEATABLE READ'
def get_admin_test_context(db_url):
"""
get_admin_test_context is used to provide a test context. A new session is
created using the db url specified
"""
ctx = context.Context(user_id=None,
tenant_id=None,
is_admin=True,
overwrite=False)
facade = session.EngineFacade(db_url, mysql_sql_mode='STRICT_ALL_TABLES')
ctx._session = facade.get_session(autocommit=False, expire_on_commit=True)
return ctx
def __init__(self, conf, url):
options = dict(conf.database.items())
# set retries to 0 , since reconnection is already implemented
# in storage.__init__.get_connection_from_config function
options['max_retries'] = 0
# add vitrage opts to database group
for opt in storage.OPTS:
options.pop(opt.name, None)
self._engine_facade = db_session.EngineFacade(self._dress_url(url),
**options)
self.conf = conf
self._active_actions = ActiveActionsConnection(self._engine_facade)
self._events = EventsConnection(self._engine_facade)
def setup_db():
try:
engine = db_session.EngineFacade(cfg.CONF.database.connection,
sqlite_fk=True).get_engine()
models.MaintenanceSession.metadata.create_all(engine)
models.MaintenanceActionPlugin.metadata.create_all(engine)
models.MaintenanceActionPluginInstance.metadata.create_all(engine)
models.MaintenanceHost.metadata.create_all(engine)
models.MaintenanceProject.metadata.create_all(engine)
models.MaintenanceInstance.metadata.create_all(engine)
except sa.exc.OperationalError as e:
LOG.error("Database registration exception: %s", e)
return False
return True
def _create_facade_lazily():
global _LOCK
with _LOCK:
global _FACADE
if _FACADE is None:
_FACADE = db_session.EngineFacade(CONF.database.connection,
**dict(CONF.database))
if CONF.profiler.profiler_enabled:
if CONF.profiler.trace_sqlalchemy:
osprofiler.sqlalchemy.add_tracing(sqlalchemy,
_FACADE.get_engine(),
"db")
return _FACADE
def test_slave_connection_string_not_provided(self):
master_path = 'sqlite:///' + self.create_tempfiles([('db.master', '')],
ext='')[0]
facade = session.EngineFacade(sql_connection=master_path)
master = facade.get_engine()
slave = facade.get_engine(use_slave=True)
self.assertIs(master, slave)
self.assertEqual(master_path, str(master.url))
master_session = facade.get_session()
self.assertEqual(master_path, str(master_session.bind.url))
slave_session = facade.get_session(use_slave=True)
self.assertEqual(master_path, str(slave_session.bind.url))
def _create_facade(conf_group):
return db_session.EngineFacade(
sql_connection=conf_group.db_connection,
autocommit=True,
expire_on_commit=False,
mysql_sql_mode=conf_group.mysql_sql_mode,
idle_timeout=conf_group.idle_timeout,
connection_debug=conf_group.connection_debug,
max_pool_size=conf_group.max_pool_size,
max_overflow=conf_group.max_overflow,
pool_timeout=conf_group.pool_timeout,
sqlite_synchronous=conf_group.sqlite_synchronous,
connection_trace=conf_group.connection_trace,
max_retries=conf_group.max_retries,
retry_interval=conf_group.retry_interval)
def _get_facade():
global _facade
if not _facade:
_facade = db_session.EngineFacade(
cfg.CONF.database.connection,
sqlite_fk=True,
autocommit=False,
**dict(six.iteritems(cfg.CONF.database)))
if cfg.CONF.profiler.enabled:
if cfg.CONF.profiler.trace_sqlalchemy:
osprofiler.sqlalchemy.add_tracing(sa, _facade.get_engine(),
'db')
return _facade
def _create_facade(conf_group):
# This fragment is copied from oslo.db
return db_session.EngineFacade(
sql_connection=conf_group.connection,
slave_connection=conf_group.slave_connection,
sqlite_fk=False,
autocommit=True,
expire_on_commit=False,
mysql_sql_mode=conf_group.mysql_sql_mode,
connection_debug=conf_group.connection_debug,
max_pool_size=conf_group.max_pool_size,
max_overflow=conf_group.max_overflow,
pool_timeout=conf_group.pool_timeout,
sqlite_synchronous=conf_group.sqlite_synchronous,
connection_trace=conf_group.connection_trace,
max_retries=conf_group.max_retries,
retry_interval=conf_group.retry_interval)
def __init__(self, conf, url):
# Set max_retries to 0, since oslo.db in certain cases may attempt
# to retry making the db connection retried max_retries ^ 2 times
# in failure case and db reconnection has already been implemented
# in storage.__init__.get_connection_from_config function
options = dict(conf.database.items())
options['max_retries'] = 0
# oslo.db doesn't support options defined by Aodh
for opt in storage.OPTS:
options.pop(opt.name, None)
self._engine_facade = db_session.EngineFacade(self.dress_url(url),
**options)
if osprofiler_sqlalchemy:
osprofiler_sqlalchemy.add_tracing(sqlalchemy,
self._engine_facade.get_engine(),
'db')
self.conf = conf
def test_slave_connection(self):
paths = self.create_tempfiles([('db.master', ''), ('db.slave', '')],
ext='')
master_path = 'sqlite:///' + paths[0]
slave_path = 'sqlite:///' + paths[1]
facade = session.EngineFacade(sql_connection=master_path,
slave_connection=slave_path)
master = facade.get_engine()
self.assertEqual(master_path, str(master.url))
slave = facade.get_engine(use_slave=True)
self.assertEqual(slave_path, str(slave.url))
master_session = facade.get_session()
self.assertEqual(master_path, str(master_session.bind.url))
slave_session = facade.get_session(use_slave=True)
self.assertEqual(slave_path, str(slave_session.bind.url))
def __init__(self, connection_string=None):
if not connection_string:
connection_string = conf.database.connection_string
try:
self._engine_facade = db_session.EngineFacade(connection_string,
autocommit=False)
except Exception:
nagios_message = "CRITICAL|CONDB001 - "
err_message = "Could not establish database connection"
LOG.error(nagios_message + err_message)
raise Exception(err_message)
# self._engine = create_engine(connection_string, echo=True)
# self.session_maker = sessionmaker(bind=self.get_engine())
self._session = None
listen(self.session, 'before_flush', on_before_flush)
self.flavor_record = None
def _create_facade_lazily():
global _LOCK
with _LOCK:
global _FACADE
if _FACADE is None:
_FACADE = db_session.EngineFacade(CONF.database.connection,
**dict(CONF.database))
# NOTE(geguileo): To avoid a cyclical dependency we import the
# group here. Dependency cycle is objects.base requires db.api,
# which requires db.sqlalchemy.api, which requires service which
# requires objects.base
CONF.import_group("profiler", "jacket.service")
if CONF.profiler.enabled:
if CONF.profiler.trace_sqlalchemy:
osprofiler_sqlalchemy.add_tracing(sqlalchemy,
_FACADE.get_engine(),
"db")
return _FACADE
def __init__(self, url):
options = dict(CONF.database.items())
# set retries to 0 , since reconnection is already implemented
# in storage.__init__.get_connection_from_config function
options['max_retries'] = 0
# add vitrage opts to database group
for opt in storage.OPTS:
options.pop(opt.name, None)
self._engine_facade = db_session.EngineFacade(self._dress_url(url),
**options)
self._active_actions = ActiveActionsConnection(self._engine_facade)
self._events = EventsConnection(self._engine_facade)
self._templates = TemplatesConnection(self._engine_facade)
self._graph_snapshots = GraphSnapshotsConnection(self._engine_facade)
self._webhooks = WebhooksConnection(self._engine_facade)
self._alarms = AlarmsConnection(self._engine_facade)
self._edges = EdgesConnection(self._engine_facade)
self._changes = ChangesConnection(self._engine_facade)
self._history_facade = HistoryFacadeConnection(self._engine_facade,
self._alarms,
self._edges,
self._changes)
def _init_engine(user, password, host):
return session.EngineFacade(
"mysql+pymysql://%s:%s@%s:3306" % (user, password, host),
pool_recycle=1800, echo=True
).get_engine()
def setUp(self):
super(EngineFacadeTestCase, self).setUp()
self.facade = session.EngineFacade('sqlite://')
def get_facade():
global _facade
if not _facade:
_facade = db_session.EngineFacade(CONF.database.connection)
return _facade
def _create_facade_lazily(name):
if name not in _FACADES:
_FACADES[name] = session.EngineFacade(
cfg.CONF[name].connection, **dict(cfg.CONF[name].iteritems()))
return _FACADES[name]
def test_direct_invocation_deprecated_args(self):
facade = session.EngineFacade("sqlite://", idle_timeout=59)
self.assertEqual(59, facade.get_engine().pool._recycle)
def __init__(self, url=None):
options = dict(CONF.pdns_database.items())
if url is None:
url = options['connection']
self.engine_facade = db_session.EngineFacade(url, **options)
self.session = self.engine_facade.get_session()
def __init__(self, conf):
self.conf = conf
options = dict(conf.database)
options['max_retries'] = 0
self.engineFacade = dbSession.EngineFacade(conf.database.connection,
**options)
def _init_engine(user, password, host):
return session.EngineFacade("mysql+pymysql://%s:%s@%s:3306" %
(user, password, host)).get_engine()
def __init__(self, url):
self._engine_facade = db_session.EngineFacade(url)
def _create_facade_lazily():
global _FACADE
if _FACADE is None:
_FACADE = db_session.EngineFacade(CONF.database.connection,
**dict(CONF.database))
return _FACADE
def drop_db():
engine = db_session.EngineFacade(CONF.database.connection,
sqlite_fk=True).get_engine()
models.Base.metadata.drop_all(engine)
return True
def __init__(self, url, max_retries, retries_interval):
self._engine_facade = db_session.EngineFacade(
url, max_retries=max_retries, retry_interval=retries_interval)
