def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
try:
connectable = placement_db.get_placement_engine()
except db_exc.CantStartEngineError:
# We are being called from a context where the database hasn't been
# configured so we need to set up Config and config the database.
# This is usually the alembic command line.
config = cfg.ConfigOpts()
conf.register_opts(config)
config([], project="placement", default_config_files=None)
placement_db.configure(config)
connectable = placement_db.get_placement_engine()
with connectable.connect() as connection:
context.configure(connection=connection,
target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
def init_application():
# initialize the config system
conffiles = _get_config_files()
config = cfg.ConfigOpts()
conf.register_opts(config)
# This will raise cfg.RequiredOptError when a required option is not set
# (notably the database connection string). We want this to be a hard fail
# that prevents the application from starting. The error will show up in
# the wsgi server's logs.
_parse_args(config, [], default_config_files=conffiles)
# initialize the logging system
setup_logging(config)
# configure database
db_api.configure(config)
# dump conf at debug if log_options
if config.log_options:
config.log_opt_values(logging.getLogger(__name__), logging.DEBUG)
setup_profiler(config)
# build and return our WSGI app
return deploy.loadapp(config)
def __init__(self, conf_fixture, set_config=False):
"""Create a database fixture."""
super(Database, self).__init__()
if set_config:
try:
conf_fixture.register_opt(
cfg.StrOpt('connection'), group='placement_database')
except cfg.DuplicateOptError:
# already registered
pass
conf_fixture.config(connection='sqlite://',
group='placement_database')
self.conf_fixture = conf_fixture
self.get_engine = placement_db.get_placement_engine
placement_db.configure(self.conf_fixture.conf)
def __init__(self, database='placement', connection=None):
"""Create a database fixture.
:param database: The type of database: 'placement'
:param connection: The connection string to use
"""
super(Database, self).__init__()
# NOTE(pkholkin): oslo_db.enginefacade is configured in tests the same
# way as it is done for any other service that uses db
global SESSION_CONFIGURED
if not SESSION_CONFIGURED:
placement_db.configure(CONF)
SESSION_CONFIGURED = True
self.database = database
self.get_engine = placement_db.get_placement_engine
def main():
# Set up the configuration to configure the database.
config = cfg.ConfigOpts()
conf.register_opts(config)
# Register cli opts before parsing args.
upgradecheck.register_cli_options(config, Checks(config))
# A slice of sys.argv is provided to pass the command line
# arguments for processing, without the name of the calling
# script ('placement-status'). If we were using
# upgradecheck.main() directly, it would do it for us, but
# we do not because of the need to configure the database
# first.
config(args=sys.argv[1:], project='placement')
db_api.configure(config)
return upgradecheck.run(config)
def init_application():
# initialize the config system
conffile = _get_config_file()
_parse_args([], default_config_files=[conffile])
db_api.configure(conf.CONF)
# initialize the logging system
setup_logging(conf.CONF)
# dump conf at debug if log_options
if conf.CONF.log_options:
conf.CONF.log_opt_values(logging.getLogger(__name__), logging.DEBUG)
# build and return our WSGI app
return deploy.loadapp(conf.CONF)
def test_can_call_configure_twice(self, configure_mock):
"""This test asserts that configure can be safely called twice
which may happen if placement is run under mod_wsgi and the
wsgi application is reloaded.
"""
db_api.configure(self.conf_fixture.conf)
configure_mock.assert_called_once()
# a second invocation of configure on a transaction context
# should raise an exception so mock this and assert its not
# called on a second invocation of db_api's configure function
configure_mock.side_effect = TypeError()
db_api.configure(self.conf_fixture.conf)
# Note we have not reset the mock so it should
# have been called once from the first invocation of
# db_api.configure and the second invocation should not
# have called it again
configure_mock.assert_called_once()
def main():
config = cfg.ConfigOpts()
conf.register_opts(config)
command_opts = setup_commands(config)
config.register_cli_opts(command_opts)
config(sys.argv[1:],
project='placement',
version=version_info.version_string(),
default_config_files=None)
db_api.configure(config)
try:
func = config.command.func
return_code = func()
# If return_code ends up None we assume 0.
sys.exit(return_code or 0)
except cfg.NoSuchOptError:
config.print_help()
sys.exit(1)
def init_application():
# initialize the config system
conffile = _get_config_file()
_parse_args([], default_config_files=[conffile])
db_api.configure(conf.CONF)
# initialize the logging system
setup_logging(conf.CONF)
# dump conf at debug (log_options option comes from oslo.service)
# FIXME(mriedem): This is gross but we don't have a public hook into
# oslo.service to register these options, so we are doing it manually for
# now; remove this when we have a hook method into oslo.service.
conf.CONF.register_opts(service_opts.service_opts)
if conf.CONF.log_options:
conf.CONF.log_opt_values(
logging.getLogger(__name__),
logging.DEBUG)
# build and return our WSGI app
return deploy.loadapp(conf.CONF)
