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)