def main():
cfg.parse_args(sys.argv)
logging.setup(CONF, None)
debug_utils.setup()
from trove.guestagent import dbaas
manager = dbaas.datastore_registry().get(CONF.datastore_manager)
if not manager:
msg = (_("Manager class not registered for datastore manager %s") %
CONF.datastore_manager)
raise RuntimeError(msg)
if not CONF.guest_id:
msg = (_("The guest_id parameter is not set. guest_info.conf "
"was not injected into the guest or not read by guestagent"))
raise RuntimeError(msg)
# BUG(1650518): Cleanup in the Pike release
# make it fatal if CONF.instance_rpc_encr_key is None
# rpc module must be loaded after decision about thread monkeypatching
# because if thread module is not monkeypatched we can't use eventlet
# executor from oslo_messaging library.
from trove import rpc
rpc.init(CONF)
from trove.common.rpc import service as rpc_service
server = rpc_service.RpcService(
key=CONF.instance_rpc_encr_key,
topic="guestagent.%s" % CONF.guest_id,
manager=manager, host=CONF.guest_id,
rpc_api_version=guest_api.API.API_LATEST_VERSION)
launcher = openstack_service.launch(CONF, server, restart_method='mutate')
launcher.wait()
def main():
log_levels = [
'docker=WARN',
]
default_log_levels = logging.get_default_log_levels()
default_log_levels.extend(log_levels)
logging.set_defaults(default_log_levels=default_log_levels)
logging.register_options(CONF)
cfg.parse_args(sys.argv)
logging.setup(CONF, None)
debug_utils.setup()
from trove.guestagent import dbaas
manager = dbaas.datastore_registry().get(CONF.datastore_manager)
if not manager:
msg = (_("Manager class not registered for datastore manager %s") %
CONF.datastore_manager)
raise RuntimeError(msg)
if not CONF.guest_id:
msg = (_("The guest_id parameter is not set. guest_info.conf "
"was not injected into the guest or not read by guestagent"))
raise RuntimeError(msg)
# Create user and group for running docker container.
LOG.info('Creating user and group for database service')
uid = cfg.get_configuration_property('database_service_uid')
operating_system.create_user('database', uid)
# Mount device if needed.
# When doing rebuild, the device should be already formatted but not
# mounted.
device_path = CONF.get(CONF.datastore_manager).device_path
mount_point = CONF.get(CONF.datastore_manager).mount_point
device = volume.VolumeDevice(device_path)
if not device.mount_points(device_path):
LOG.info('Preparing the storage for %s, mount path %s',
device_path, mount_point)
device.format()
device.mount(mount_point)
operating_system.chown(mount_point, CONF.database_service_uid,
CONF.database_service_uid,
recursive=True, as_root=True)
# rpc module must be loaded after decision about thread monkeypatching
# because if thread module is not monkeypatched we can't use eventlet
# executor from oslo_messaging library.
from trove import rpc
rpc.init(CONF)
from trove.common.rpc import service as rpc_service
server = rpc_service.RpcService(
key=CONF.instance_rpc_encr_key,
topic="guestagent.%s" % CONF.guest_id,
manager=manager, host=CONF.guest_id,
rpc_api_version=guest_api.API.API_LATEST_VERSION)
launcher = openstack_service.launch(CONF, server, restart_method='mutate')
launcher.wait()
def main():
cfg.parse_args(sys.argv)
logging.setup(CONF, None)
debug_utils.setup()
from trove.guestagent import dbaas
manager = dbaas.datastore_registry().get(CONF.datastore_manager)
if not manager:
msg = ("Manager class not registered for datastore manager %s" %
CONF.datastore_manager)
raise RuntimeError(msg)
# rpc module must be loaded after decision about thread monkeypatching
# because if thread module is not monkeypatched we can't use eventlet
# executor from oslo_messaging library.
from trove import rpc
rpc.init(CONF)
from trove.common.rpc import service as rpc_service
from trove.common.rpc import version as rpc_version
server = rpc_service.RpcService(
manager=manager, host=CONF.guest_id,
rpc_api_version=rpc_version.RPC_API_VERSION)
launcher = openstack_service.launch(CONF, server)
launcher.wait()
def startup(conf, topic):
from trove.common.rpc import service as rpc_service
from trove.openstack.common import service as openstack_service
server = rpc_service.RpcService(manager=conf.taskmanager_manager,
topic=topic)
launcher = openstack_service.launch(server)
launcher.wait()
def launch_services():
get_db_api().configure_db(CONF)
manager = 'trove.conductor.manager.Manager'
topic = CONF.conductor_queue
server = rpc_service.RpcService(manager=manager, topic=topic)
launcher = openstack_service.launch(server,
workers=CONF.trove_conductor_workers)
launcher.wait()
def start_fake_taskmanager(conf):
topic = conf.taskmanager_queue
from trove.common.rpc import service as rpc_service
from trove.common.rpc import version as rpc_version
taskman_service = rpc_service.RpcService(
key='', topic=topic, rpc_api_version=rpc_version.RPC_API_VERSION,
manager='trove.taskmanager.manager.Manager')
taskman_service.start()
def main(conf):
from trove.common.rpc import service as rpc_service
from trove.openstack.common import service as openstack_service
topic = conf.conductor_queue
server = rpc_service.RpcService(manager=conf.conductor_manager,
topic=topic)
workers = conf.trove_conductor_workers or processutils.get_worker_count()
launcher = openstack_service.launch(server, workers=workers)
launcher.wait()
def startup(conf, topic):
from trove.common.rpc import service as rpc_service
from trove.common.rpc import version as rpc_version
from trove.openstack.common import service as openstack_service
server = rpc_service.RpcService(
manager=conf.taskmanager_manager, topic=topic,
rpc_api_version=rpc_version.RPC_API_VERSION)
launcher = openstack_service.launch(server)
launcher.wait()
def main(conf):
from trove.common.rpc import service as rpc_service
from trove.openstack.common import service as openstack_service
manager = 'trove.conductor.manager.Manager'
topic = conf.conductor_queue
server = rpc_service.RpcService(manager=manager, topic=topic)
launcher = openstack_service.launch(server,
workers=conf.trove_conductor_workers)
launcher.wait()
def main(conf):
from trove.common.rpc import service as rpc_service
from trove.common.rpc import version as rpc_version
topic = conf.conductor_queue
server = rpc_service.RpcService(
manager=conf.conductor_manager,
topic=topic,
rpc_api_version=rpc_version.RPC_API_VERSION)
workers = conf.trove_conductor_workers or processutils.get_worker_count()
launcher = openstack_service.launch(conf, server, workers=workers)
launcher.wait()
def startup(conf, topic):
from trove.common import notification
from trove.common.rpc import service as rpc_service
from trove.instance import models as inst_models
notification.DBaaSAPINotification.register_notify_callback(
inst_models.persist_instance_fault)
server = rpc_service.RpcService(
manager=conf.taskmanager_manager,
topic=topic,
rpc_api_version=task_api.API.API_LATEST_VERSION)
launcher = openstack_service.launch(conf, server)
launcher.wait()
def main(conf):
from trove.common import notification
from trove.common.rpc import service as rpc_service
from trove.instance import models as inst_models
notification.DBaaSAPINotification.register_notify_callback(
inst_models.persist_instance_fault)
topic = conf.conductor_queue
server = rpc_service.RpcService(
manager=conf.conductor_manager,
topic=topic,
rpc_api_version=conductor_api.API.API_LATEST_VERSION)
workers = conf.trove_conductor_workers or processutils.get_worker_count()
launcher = openstack_service.launch(conf, server, workers=workers)
launcher.wait()
def initialize_trove(config_file):
from trove.openstack.common import pastedeploy
cfg.CONF(args=[],
project='trove',
default_config_files=[config_file])
logging.setup(None)
topic = CONF.taskmanager_queue
rpc.init(CONF)
taskman_service = rpc_service.RpcService(
None, topic=topic, rpc_api_version=rpc_version.RPC_API_VERSION,
manager='trove.taskmanager.manager.Manager')
taskman_service.start()
return pastedeploy.paste_deploy_app(config_file, 'trove', {})
def main():
cfg.parse_args(sys.argv)
from trove.guestagent import dbaas
logging.setup(None)
debug_utils.setup()
# Patch 'thread' module if debug is disabled
if not debug_utils.enabled():
eventlet.monkey_patch(thread=True)
manager = dbaas.datastore_registry().get(CONF.datastore_manager)
if not manager:
msg = ("Manager class not registered for datastore manager %s" %
CONF.datastore_manager)
raise RuntimeError(msg)
server = rpc_service.RpcService(manager=manager, host=CONF.guest_id)
launcher = openstack_service.launch(server)
launcher.wait()
def startup(topic):
cfg.parse_args(sys.argv)
logging.setup(None)
debug_utils.setup()
# Patch 'thread' module if debug is disabled
if not debug_utils.enabled():
eventlet.monkey_patch(thread=True)
from trove.common.rpc import service as rpc_service
from trove.openstack.common import service as openstack_service
from trove.db import get_db_api
get_db_api().configure_db(CONF)
server = rpc_service.RpcService(manager=CONF.taskmanager_manager,
topic=topic)
launcher = openstack_service.launch(server)
launcher.wait()
def startup(conf, topic):
from trove.common import notification
from trove.common.rpc import service as rpc_service
from trove.instance import models as inst_models
from trove.taskmanager import api as task_api
notification.DBaaSAPINotification.register_notify_callback(
inst_models.persist_instance_fault)
if conf.enable_secure_rpc_messaging:
key = conf.taskmanager_rpc_encr_key
else:
key = None
server = rpc_service.RpcService(
key=key, manager=conf.taskmanager_manager, topic=topic,
rpc_api_version=task_api.API.API_LATEST_VERSION)
launcher = openstack_service.launch(conf, server,
restart_method='mutate')
launcher.wait()
def main(conf):
from trove.common import notification
from trove.common.rpc import conductor_host_serializer as sz
from trove.common.rpc import service as rpc_service
from trove.instance import models as inst_models
notification.DBaaSAPINotification.register_notify_callback(
inst_models.persist_instance_fault)
topic = conf.conductor_queue
server = rpc_service.RpcService(
key=None,
manager=conf.conductor_manager,
topic=topic,
rpc_api_version=conductor_api.API.API_LATEST_VERSION,
secure_serializer=sz.ConductorHostSerializer)
workers = conf.trove_conductor_workers or processutils.get_worker_count()
launcher = openstack_service.launch(conf,
server,
workers=workers,
restart_method='mutate')
launcher.wait()