def _get_service(self):
if self.status._is_query_router() is True:
return (operating_system.service_discovery(
system.MONGOS_SERVICE_CANDIDATES))
else:
return (operating_system.service_discovery(
system.MONGOD_SERVICE_CANDIDATES))
def _disable_db_on_boot(self):
LOG.info(_("Disabling Couchbase Server on boot"))
try:
couchbase_service = operating_system.service_discovery(system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchbase_service["cmd_disable"], shell=True)
except KeyError:
raise RuntimeError("Command to disable Couchbase Server on boot not found.")
def _enable_mysql_on_boot(self):
LOG.info("Enabling mysql on boot.")
try:
mysql_service = operating_system.service_discovery(MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service["cmd_enable"], shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
def start_mysql(self, update_db=False):
LOG.info(_("Starting mysql..."))
# This is the site of all the trouble in the restart tests.
# Essentially what happens is that mysql start fails, but does not
# die. It is then impossible to kill the original, so
self._enable_mysql_on_boot()
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_start'], shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
except exception.ProcessExecutionError:
# it seems mysql (percona, at least) might come back with [Fail]
# but actually come up ok. we're looking into the timing issue on
# parallel, but for now, we'd like to give it one more chance to
# come up. so regardless of the execute_with_timeout() response,
# we'll assume mysql comes up and check it's status for a while.
pass
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of MySQL failed!"))
# If it won't start, but won't die either, kill it by hand so we
# don't let a rouge process wander around.
try:
utils.execute_with_timeout("sudo", "pkill", "-9", "mysql")
except exception.ProcessExecutionError as p:
LOG.error("Error killing stalled mysql start command.")
LOG.error(p)
# There's nothing more we can do...
self.status.end_install_or_restart()
raise RuntimeError("Could not start MySQL!")
def start_mysql(self, update_db=False):
LOG.info(_("Starting MySQL."))
# This is the site of all the trouble in the restart tests.
# Essentially what happens is that mysql start fails, but does not
# die. It is then impossible to kill the original, so
self._enable_mysql_on_boot()
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_start'], shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
except exception.ProcessExecutionError:
# it seems mysql (percona, at least) might come back with [Fail]
# but actually come up ok. we're looking into the timing issue on
# parallel, but for now, we'd like to give it one more chance to
# come up. so regardless of the execute_with_timeout() response,
# we'll assume mysql comes up and check it's status for a while.
pass
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of MySQL failed."))
# If it won't start, but won't die either, kill it by hand so we
# don't let a rouge process wander around.
try:
utils.execute_with_timeout("sudo", "pkill", "-9", "mysql")
except exception.ProcessExecutionError:
LOG.exception(_("Error killing stalled MySQL start command."))
# There's nothing more we can do...
self.status.end_install_or_restart()
raise RuntimeError("Could not start MySQL!")
def start_db(self, update_db=False):
"""
Start the Couchbase Server.
"""
LOG.info(_("Starting Couchbase Server..."))
self._enable_db_on_boot()
try:
couchbase_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(
couchbase_service['cmd_start'], shell=True)
except exception.ProcessExecutionError:
pass
except KeyError:
raise RuntimeError("Command to start Couchbase Server not found.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of Couchbase Server failed!"))
try:
utils.execute_with_timeout(system.cmd_kill)
except exception.ProcessExecutionError as p:
LOG.error('Error killing stalled Couchbase start command.')
LOG.error(p)
self.status.end_install_or_restart()
raise RuntimeError("Could not start Couchbase Server")
def start_db(self, update_db=False):
"""
Start the Couchbase Server.
"""
LOG.info(_("Starting Couchbase Server..."))
self._enable_db_on_boot()
try:
couchbase_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchbase_service['cmd_start'],
shell=True)
except exception.ProcessExecutionError:
pass
except KeyError:
raise RuntimeError("Command to start Couchbase Server not found.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of Couchbase Server failed!"))
try:
utils.execute_with_timeout(system.cmd_kill)
except exception.ProcessExecutionError as p:
LOG.error('Error killing stalled Couchbase start command.')
LOG.error(p)
self.status.end_install_or_restart()
raise RuntimeError("Could not start Couchbase Server")
def start_db(self, update_db=False):
LOG.info(_("Starting MongoDB"))
self._enable_db_on_boot()
try:
mongodb_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(mongodb_service['cmd_start'],
shell=True)
except ProcessExecutionError:
pass
except KeyError:
raise RuntimeError("MongoDB service is not discovered.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of MongoDB failed"))
# If it won't start, but won't die either, kill it by hand so we
# don't let a rouge process wander around.
try:
out, err = utils.execute_with_timeout(
system.FIND_PID, shell=True)
pid = "".join(out.split(" ")[1:2])
utils.execute_with_timeout(
system.MONGODB_KILL % pid, shell=True)
except exception.ProcessExecutionError as p:
LOG.error("Error killing stalled MongoDB start command.")
LOG.error(p)
# There's nothing more we can do...
self.status.end_install_or_restart()
raise RuntimeError("Could not start MongoDB")
def _disable_db_on_boot(self):
try:
LOG.debug("Disable CouchDB on boot.")
couchdb_service = operating_system.service_discovery(system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchdb_service["cmd_disable"], shell=True)
except KeyError:
raise RuntimeError("Command to disable CouchDB server on boot not found.")
def start_db(self, update_db=False):
LOG.info(_("Starting MongoDB"))
self._enable_db_on_boot()
try:
mongodb_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(mongodb_service['cmd_start'],
shell=True)
except ProcessExecutionError:
pass
except KeyError:
raise RuntimeError("MongoDB service is not discovered.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.RUNNING,
self.state_change_wait_time, update_db):
LOG.error(_("Start up of MongoDB failed"))
# If it won't start, but won't die either, kill it by hand so we
# don't let a rouge process wander around.
try:
out, err = utils.execute_with_timeout(
system.FIND_PID, shell=True)
pid = "".join(out.split(" ")[1:2])
utils.execute_with_timeout(
system.MONGODB_KILL % pid, shell=True)
except exception.ProcessExecutionError as p:
LOG.error("Error killing stalled MongoDB start command.")
LOG.error(p)
# There's nothing more we can do...
self.status.end_install_or_restart()
raise RuntimeError("Could not start MongoDB")
def _disable_mysql_on_boot(self):
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_disable'],
shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
def _disable_mysql_on_boot(self):
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_disable'],
shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
def _enable_pgsql_on_boot(self):
try:
pgsql_service = operating_system.service_discovery(
PGSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(pgsql_service['cmd_enable'], shell=True)
except KeyError:
LOG.exception(_("Error enabling PostgreSQL start on boot."))
raise RuntimeError("Service is not discovered.")
def _disable_db_on_boot(self):
LOG.info(_("Disabling MongoDB on boot"))
try:
mongodb_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(mongodb_service['cmd_disable'],
shell=True)
except KeyError:
raise RuntimeError("MongoDB service is not discovered.")
def _enable_mysql_on_boot(self):
LOG.debug("Enabling MySQL on boot.")
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_enable'], shell=True)
except KeyError:
LOG.exception(_("Error enabling MySQL start on boot."))
raise RuntimeError("Service is not discovered.")
def _enable_mysql_on_boot(self):
LOG.debug("Enabling MySQL on boot.")
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_enable'], shell=True)
except KeyError:
LOG.exception(_("Error enabling MySQL start on boot."))
raise RuntimeError("Service is not discovered.")
def _disable_db_on_boot(self):
LOG.info(_("Disabling MongoDB on boot"))
try:
mongodb_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(mongodb_service['cmd_disable'],
shell=True)
except KeyError:
raise RuntimeError("MongoDB service is not discovered.")
def _disable_pgsql_on_boot(self):
try:
pgsql_service = operating_system.service_discovery(
PGSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(pgsql_service['cmd_disable'],
shell=True)
except KeyError:
LOG.exception(_("Error disabling PostgreSQL start on boot."))
raise RuntimeError("Service is not discovered.")
def _disable_db_on_boot(self):
LOG.info(_("Disabling Couchbase Server on boot"))
try:
couchbase_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchbase_service['cmd_disable'],
shell=True)
except KeyError:
raise RuntimeError(
"Command to disable Couchbase Server on boot not found.")
def stop_db(self, context):
"""Stop the PgSql service."""
cmd = operating_system.service_discovery(PGSQL_SERVICE_CANDIDATES)
LOG.info(
_("{guest_id}: Stopping database engine with command ({command})."
).format(
guest_id=CONF.guest_id,
command=cmd['cmd_stop'],
))
utils.execute_with_timeout(*cmd['cmd_stop'].split(), timeout=30)
def service_discovery(service_candidates):
result = operating_system.service_discovery(service_candidates)
if result['type'] == 'sysvinit':
result['cmd_bootstrap_pxc_cluster'] = ("sudo service %s bootstrap-pxc"
% result['service'])
elif result['type'] == 'systemd':
result['cmd_bootstrap_pxc_cluster'] = ("sudo systemctl start "
"*****@*****.**"
% result['service'])
return result
def service_discovery(service_candidates):
result = operating_system.service_discovery(service_candidates)
if result['type'] == 'sysvinit':
result['cmd_bootstrap_pxc_cluster'] = (
"sudo service %s bootstrap-pxc" % result['service'])
elif result['type'] == 'systemd':
result['cmd_bootstrap_pxc_cluster'] = ("systemctl start "
"*****@*****.**" %
result['service'])
return result
def _disable_redis_on_boot(self):
"""
Disables redis on boot.
"""
LOG.info(_("Disabling Redis on boot."))
try:
redis_service = operating_system.service_discovery(system.SERVICE_CANDIDATES)
utils.execute_with_timeout(redis_service["cmd_disable"], shell=True)
except KeyError:
raise RuntimeError("Command to disable Redis on boot not found.")
def _enable_db_on_boot(self):
try:
LOG.debug("Enable CouchDB on boot.")
couchdb_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchdb_service['cmd_enable'],
shell=True)
except KeyError:
raise RuntimeError(
"Command to disable CouchDB server on boot not found.")
def _enable_redis_on_boot(self):
"""
Enables redis on boot.
"""
LOG.info(_('Enabling Redis on boot.'))
try:
redis_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(redis_service['cmd_enable'], shell=True)
except KeyError:
raise RuntimeError(_("Command to enable Redis on boot not found."))
def _enable_db_on_boot(self):
"""
Enables Couchbase Server on boot.
"""
LOG.info(_('Enabling Couchbase Server on boot.'))
try:
couchbase_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(
couchbase_service['cmd_enable'], shell=True)
except KeyError:
raise RuntimeError(_(
"Command to enable Couchbase Server on boot not found."))
def stop_db(self, context):
"""Stop the PgSql service."""
cmd = operating_system.service_discovery(PGSQL_SERVICE_CANDIDATES)
LOG.info(
_("{guest_id}: Stopping database engine with command ({command}).")
.format(
guest_id=CONF.guest_id,
command=cmd['cmd_stop'],
)
)
utils.execute_with_timeout(
*cmd['cmd_stop'].split(),
timeout=30
)
def stop_db(self, update_db=False, do_not_start_on_reboot=False):
LOG.info(_("Stopping mysql..."))
if do_not_start_on_reboot:
self._disable_mysql_on_boot()
try:
mysql_service = operating_system.service_discovery(MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service["cmd_stop"], shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN, self.state_change_wait_time, update_db
):
LOG.error(_("Could not stop MySQL!"))
self.status.end_install_or_restart()
raise RuntimeError("Could not stop MySQL!")
def stop_db(self, update_db=False, do_not_start_on_reboot=False):
LOG.info(_("Stopping mysql..."))
if do_not_start_on_reboot:
self._disable_mysql_on_boot()
try:
mysql_service = operating_system.service_discovery(
MYSQL_SERVICE_CANDIDATES)
utils.execute_with_timeout(mysql_service['cmd_stop'], shell=True)
except KeyError:
raise RuntimeError("Service is not discovered.")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN,
self.state_change_wait_time, update_db):
LOG.error(_("Could not stop MySQL!"))
self.status.end_install_or_restart()
raise RuntimeError("Could not stop MySQL!")
def stop_db(self, update_db=False, do_not_start_on_reboot=False):
"""
Stops Couchbase Server on the trove instance.
"""
LOG.info(_("Stopping Couchbase Server..."))
if do_not_start_on_reboot:
self._disable_db_on_boot()
try:
couchbase_service = operating_system.service_discovery(system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchbase_service["cmd_stop"], shell=True)
except KeyError:
raise RuntimeError("Command to stop Couchbase Server not found")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN, self.state_change_wait_time, update_db
):
LOG.error(_("Could not stop Couchbase Server!"))
self.status.end_install_or_restart()
raise RuntimeError(_("Could not stop Couchbase Server"))
def stop_db(self, update_db=False, do_not_start_on_reboot=False):
"""
Stops Couchbase Server on the trove instance.
"""
LOG.info(_('Stopping Couchbase Server...'))
if do_not_start_on_reboot:
self._disable_db_on_boot()
try:
couchbase_service = operating_system.service_discovery(
system.SERVICE_CANDIDATES)
utils.execute_with_timeout(couchbase_service['cmd_stop'],
shell=True)
except KeyError:
raise RuntimeError("Command to stop Couchbase Server not found")
if not self.status.wait_for_real_status_to_change_to(
rd_instance.ServiceStatuses.SHUTDOWN,
self.state_change_wait_time, update_db):
LOG.error(_('Could not stop Couchbase Server!'))
self.status.end_install_or_restart()
raise RuntimeError(_("Could not stop Couchbase Server"))
def test_systemd_not_symlinked_type_service_discovery(self):
with patch.object(os.path, 'isfile', side_effect=[False, False, True]):
with patch.object(os.path, 'islink', return_value=False):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service['cmd_start'])
self.assertIsNotNone(mysql_service['cmd_enable'])
def test_sysvinit_chkconfig_type_service_discovery(self):
with patch.object(os.path, 'isfile',
side_effect=[False, True, False, True]):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service['cmd_start'])
self.assertIsNotNone(mysql_service['cmd_enable'])
def mysql_service(self):
MYSQL_SERVICE_CANDIDATES = ["mysql", "mysqld", "mysql-server"]
return operating_system.service_discovery(MYSQL_SERVICE_CANDIDATES)
def mysql_service(self):
service_candidates = self.service_candidates
return operating_system.service_discovery(service_candidates)
def _get_service(self):
if self.is_query_router:
return operating_system.service_discovery(system.MONGOS_SERVICE_CANDIDATES)
else:
return operating_system.service_discovery(system.MONGOD_SERVICE_CANDIDATES)
def test_upstart_type_service_discovery(self):
with patch.object(os.path, "isfile", side_effect=[True]):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service["cmd_start"])
self.assertIsNotNone(mysql_service["cmd_enable"])
def test_systemd_symlinked_type_service_discovery(self, mock_base, mock_path, mock_islink):
with patch.object(os.path, "isfile", side_effect=[False, False, True]):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service["cmd_start"])
self.assertIsNotNone(mysql_service["cmd_enable"])
def test_sysvinit_chkconfig_type_service_discovery(self):
with patch.object(os.path, 'isfile',
side_effect=[False, True, False, True]):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service['cmd_start'])
self.assertIsNotNone(mysql_service['cmd_enable'])
def test_systemd_not_symlinked_type_service_discovery(self):
with patch.object(os.path, 'isfile', side_effect=[False, False, True]):
with patch.object(os.path, 'islink', return_value=False):
mysql_service = operating_system.service_discovery(["mysql"])
self.assertIsNotNone(mysql_service['cmd_start'])
self.assertIsNotNone(mysql_service['cmd_enable'])
def mysql_service(self):
service_candidates = self.service_candidates
return operating_system.service_discovery(service_candidates)
def mysql_service(self):
MYSQL_SERVICE_CANDIDATES = ["mysql", "mysqld", "mysql-server"]
return operating_system.service_discovery(MYSQL_SERVICE_CANDIDATES)
