def database_name(self):
databases = self._get_database_names()
if len(databases) == 0:
raise exception.GuestError('No database found on guest.')
elif len(databases) > 1:
raise exception.GuestError('Multiple databases found on guest.')
return databases[0]
def _cast(self, method_name, version, **kwargs):
LOG.debug("Casting %s" % method_name)
try:
cctxt = self.client.prepare(version=version)
cctxt.cast(self.context, method_name, **kwargs)
except RemoteError as r:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=str(e))
def _cast(self, method_name, **kwargs):
LOG.debug("Casting %s" % method_name)
try:
self.cast(self.context, self.make_msg(method_name, **kwargs),
topic=kwargs.get('topic'),
version=kwargs.get('version'))
except common.RemoteError as r:
LOG.error(r)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.error(e)
raise exception.GuestError(original_message=str(e))
def _cast(self, method_name, version, **kwargs):
LOG.debug("Calling %s asynchronously", method_name)
try:
with NotificationCastWrapper(self.context, 'guest'):
cctxt = self.client.prepare(version=version)
cctxt.cast(self.context, method_name, **kwargs)
except RemoteError as r:
LOG.exception("Error calling %s", method_name)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.exception("Error calling %s", method_name)
raise exception.GuestError(original_message=str(e))
def get_private_vip(self, ip):
if_addr_pairs = self._get_if_addr_pairs()
for i in range(len(if_addr_pairs)):
# address shows up as 192.168.70.3/24, so discard the /24
if if_addr_pairs[i][1].split('/')[0] == ip:
if if_addr_pairs[i][0] != if_addr_pairs[i + 1][0]:
raise exception.GuestError(
_("Missing interconnect {interface} virtual IP.").
format(interface=if_addr_pairs[i][0]))
return if_addr_pairs[i + 1][1].split('/')[0]
raise exception.GuestError(
_("Could not find interface with address {ip}").format(ip=ip))
def __init__(self, manager_name):
super(Manager, self).__init__(CONF)
# Manager properties
self.__manager_name = manager_name
self.__manager = None
self.__prepare_error = False
# Guest log
self._guest_log_context = None
self._guest_log_loaded_context = None
self._guest_log_cache = None
self._guest_log_defs = None
# Module
self.module_driver_manager = driver_manager.ModuleDriverManager()
# Drivers should implement
self.adm = None
self.app = None
self.status = None
if CONF.guest_agent.container_registry:
try:
self.docker_client.login(
CONF.guest_agent.container_registry_username,
CONF.guest_agent.container_registry_password,
email="",
registry=CONF.guest_agent.container_registry)
except Exception as exc:
raise exception.GuestError(f"Failed to login the container "
f"registry, error: {str(exc)}")
def delete_user(self, user):
LOG.debug("Delete a given user.")
db2_user = models.DatastoreUser.deserialize(user)
db2_user.check_delete()
userName = db2_user.name
user_dbs = db2_user.databases
LOG.debug("For user %s, databases to be deleted = %r." % (
userName, user_dbs))
if len(user_dbs) == 0:
databases = self.list_access(db2_user.name, None)
else:
databases = user_dbs
LOG.debug("databases for user = %r." % databases)
for database in databases:
mydb = models.DatastoreSchema.deserialize(database)
try:
run_command(system.REVOKE_USER_ACCESS % {
'dbname': mydb.name,
'login': userName})
LOG.debug("Revoked access for user:%s on database:%s." % (
userName, mydb.name))
except exception.ProcessExecutionError as pe:
LOG.debug("Error occurred while revoking access to %s." %
mydb.name)
pass
try:
utils.execute_with_timeout(system.DELETE_USER_COMMAND % {
'login': db2_user.name.lower()}, shell=True)
except exception.ProcessExecutionError as pe:
LOG.exception(_(
"There was an error while deleting user: %s.") % pe)
raise exception.GuestError(original_message=_(
"Unable to delete user: %s.") % userName)
def _call(self, method_name, timeout_sec, version, **kwargs):
LOG.debug("Calling %s with timeout %s" % (method_name, timeout_sec))
try:
cctxt = self.client.prepare(version=version, timeout=timeout_sec)
result = cctxt.call(self.context, method_name, **kwargs)
LOG.debug("Result is %s." % result)
return result
except RemoteError as r:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=str(e))
except Timeout:
raise exception.GuestTimeout()
def _cast_with_consumer(self, method_name, **kwargs):
conn = None
try:
conn = rpc.create_connection(new=True)
conn.create_consumer(self._get_routing_key(), None, fanout=False)
except common.RemoteError as r:
LOG.error(r)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.error(e)
raise exception.GuestError(original_message=str(e))
finally:
if conn:
conn.close()
# leave the cast call out of the hackity consumer create
self._cast(method_name, **kwargs)
def _call(self, method_name, timeout_sec, **kwargs):
LOG.debug("Calling %s with timeout %s." % (method_name, timeout_sec))
try:
result = self.call(self.context,
self.make_msg(method_name, **kwargs),
timeout=timeout_sec)
LOG.debug("Result is %s." % result)
return result
except common.RemoteError as r:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=r.value)
except Exception as e:
LOG.exception(_("Error calling %s") % method_name)
raise exception.GuestError(original_message=str(e))
except Timeout:
raise exception.GuestTimeout()
def check_format(self, device_path):
stdout, stderr = utils.execute("xfs_admin",
"-l",
device_path,
run_as_root=True,
root_helper="sudo")
if 'not a valid XFS filesystem' in stdout:
msg = _("Volume '%s' does not appear to be formatted.") % (
device_path)
raise exception.GuestError(original_message=msg)
def log_and_raise(log_fmt, exc_fmt, fmt_content=None):
if fmt_content is not None:
LOG.exception(log_fmt, fmt_content)
raise_msg = exc_fmt % fmt_content
else:
# if fmt_content is not provided, log_fmt and
# exc_fmt are just plain string messages
LOG.exception(log_fmt)
raise_msg = exc_fmt
raise_msg += _("\nExc: %s") % traceback.format_exc()
raise exception.GuestError(original_message=raise_msg)
def delete_database(self, database):
"""Delete the specified database."""
dbName = None
try:
mydb = models.DatastoreSchema.deserialize(database)
mydb.check_delete()
dbName = mydb.name
LOG.debug("Deleting DB2 database: %s.", dbName)
run_command(system.DELETE_DB_COMMAND % {'dbname': dbName})
except exception.ProcessExecutionError:
LOG.exception(
"There was an error while deleting database:%s.", dbName)
raise exception.GuestError(original_message=_(
"Unable to delete database: %s.") % dbName)
def delete_database(self, database):
"""Delete the specified database."""
dbName = None
try:
mydb = models.ValidatedMySQLDatabase()
mydb.deserialize(database)
dbName = mydb.name
LOG.debug("Deleting DB2 database: %s." % dbName)
run_command(system.DELETE_DB_COMMAND % {'dbname': dbName})
except exception.ProcessExecutionError:
LOG.exception(
_("There was an error while deleting database:%s.") % dbName)
raise exception.GuestError(
_("Unable to delete database: %s.") % dbName)
def pkg_version(self, package_name):
cmd_list = ["dpkg", "-l", package_name]
p = commands.getstatusoutput(' '.join(cmd_list))
# check the command status code
if not p[0] == 0:
return None
# Need to capture the version string
# check the command output
std_out = p[1]
patterns = [
'.*No packages found matching.*', "\w\w\s+(\S+)\s+(\S+)\s+(.*)$"
]
for line in std_out.split("\n"):
for p in patterns:
regex = re.compile(p)
matches = regex.match(line)
if matches:
line = matches.group()
parts = line.split()
if not parts:
msg = _("returned nothing")
LOG.error(msg)
raise exception.GuestError(msg)
if len(parts) <= 2:
msg = _("Unexpected output.")
LOG.error(msg)
raise exception.GuestError(msg)
if parts[1] != package_name:
msg = _("Unexpected output:[1] = %s") % str(parts[1])
LOG.error(msg)
raise exception.GuestError(msg)
if parts[0] == 'un' or parts[2] == '<none>':
return None
return parts[2]
msg = _("version() saw unexpected output from dpkg!")
LOG.error(msg)
def determine_sid(self):
hostname = self._get_hostname()
stdout, stderr = run_sys_command(
'{crsctl} stat res -w "TYPE = ora.database.type" -t'.format(
crsctl=path.join(GRID_HOME, 'bin', 'crsctl')))
instance_id = None
for line in stdout.split('\n'):
words = line.strip().split()
if hostname in words:
instance_id = words[0]
if not instance_id:
raise exception.GuestError(
_("Could not find hostname in crsctl information."))
self.admin.ora_config.cluster_sid = "{dbname}{instance_id}".format(
dbname=self.admin.ora_config.db_name, instance_id=instance_id)
def test_create_cluster_fail(self, mock_logging, mock_dv, mock_ds,
mock_find_all, mock_load, mock_ready, mock_ip,
mock_reset_task, mock_update_status):
mock_find_all.return_value.all.return_value = [self.dbinst1]
mock_load.return_value = BaseInstance(
Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_ip.return_value = "10.0.0.2"
guest_client = Mock()
guest_client.install_cluster = Mock(
side_effect=exception.GuestError("Error"))
with patch.object(ClusterTasks, 'get_guest',
return_value=guest_client):
self.clustertasks.create_cluster(Mock(), self.cluster_id)
mock_update_status.assert_called_with('1232')
mock_reset_task.assert_called_with()
def _call(self, method_name, timeout_sec, **kwargs):
LOG.debug("Calling %s with timeout %s" % (method_name, timeout_sec))
try:
result = self.call(self.context,
self.make_msg(method_name, **kwargs),
timeout=timeout_sec)
LOG.debug("Result is %s" % result)
return result
except Exception as e:
LOG.error(e)
raise exception.GuestError(original_message=str(e))
except Timeout as t:
if t is not timeout:
raise
else:
raise exception.GuestTimeout()
def delete_database(self, database):
'''Delete the specified database.'''
dbName = None
try:
dbName = models.CouchDBSchema.deserialize_schema(database).name
LOG.debug("Deleting CouchDB database: %s." % dbName)
utils.execute_with_timeout(system.DELETE_DB_COMMAND % {
'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password,
'dbname': dbName
},
shell=True)
except exception.ProcessExecutionError:
LOG.exception(
_("There was an error while deleting database:%s.") % dbName)
raise exception.GuestError(
_("Unable to delete database: %s.") % dbName)
def delete_database(self, database):
"""Delete the specified database."""
dbName = None
try:
oradb = models.OracleSchema.deserialize_schema(database)
dbName = oradb.name
LOG.debug("Deleting Oracle database: %s." % dbName)
run_command(
system.DELETE_DB_COMMAND % {
'db': dbName,
'sys_user': ADMIN_USER_NAME,
'sys_pswd': OracleConfig().admin_password
})
except exception.ProcessExecutionError:
LOG.exception(
_("There was an error while deleting database:%s.") % dbName)
raise exception.GuestError(
_("Unable to delete database: %s.") % dbName)
def guest_log_enable(self, context, log_name, disable):
"""This method can be overridden by datastore implementations to
facilitate enabling and disabling USER type logs. If the logs
can be enabled with simple configuration group changes, however,
the code here will probably suffice.
Must return whether the datastore needs to be restarted in order for
the logging to begin.
"""
restart_required = False
verb = ("Disabling" if disable else "Enabling")
if self.configuration_manager:
LOG.debug("%(verb)s log '%(log)s'", {
'verb': verb,
'log': log_name
})
gl_def = self.get_guest_log_defs()[log_name]
enable_cfg_label = "%s_%s_log" % (self.GUEST_LOG_ENABLE_LABEL,
log_name)
disable_cfg_label = "%s_%s_log" % (self.GUEST_LOG_DISABLE_LABEL,
log_name)
restart_required = gl_def.get(self.GUEST_LOG_RESTART_LABEL,
restart_required)
if disable:
self._apply_log_overrides(
context, enable_cfg_label, disable_cfg_label,
gl_def.get(self.GUEST_LOG_DISABLE_LABEL),
gl_def.get(self.GUEST_LOG_SECTION_LABEL), restart_required)
else:
self._apply_log_overrides(
context, disable_cfg_label, enable_cfg_label,
gl_def.get(self.GUEST_LOG_ENABLE_LABEL),
gl_def.get(self.GUEST_LOG_SECTION_LABEL), restart_required)
else:
log_fmt = ("%(verb)s log '%(log)s' not supported - "
"no configuration manager defined!")
exc_fmt = _("%(verb)s log '%(log)s' not supported - "
"no configuration manager defined!")
msg_content = {'verb': verb, 'log': log_name}
LOG.error(log_fmt, msg_content)
raise exception.GuestError(original_message=(exc_fmt %
msg_content))
return restart_required
def _check_format(self):
"""Checks that a volume is formatted."""
LOG.debug("Checking whether '%s' is formatted." % self.device_path)
try:
stdout, stderr = utils.execute(
"dumpe2fs", self.device_path,
run_as_root=True, root_helper="sudo")
if 'has_journal' not in stdout:
msg = _("Volume '%s' does not appear to be formatted.") % (
self.device_path)
raise exception.GuestError(original_message=msg)
except exception.ProcessExecutionError as pe:
if 'Wrong magic number' in pe.stderr:
volume_fstype = CONF.volume_fstype
msg = _("'Device '%(dev)s' did not seem to be '%(type)s'.") % (
{'dev': self.device_path, 'type': volume_fstype})
log_and_raise(msg)
msg = _("Volume '%s' was not formatted.") % self.device_path
log_and_raise(msg)
def delete_database(self, database):
'''Delete the specified database.'''
dbName = models.CouchDBSchema.deserialize(database).name
if self._is_modifiable_database(dbName):
try:
LOG.debug("Deleting CouchDB database: %s.", dbName)
utils.execute_with_timeout(
system.DELETE_DB_COMMAND %
{'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password,
'dbname': dbName},
shell=True)
except exception.ProcessExecutionError:
LOG.exception(_(
"There was an error while deleting database:%s."), dbName)
raise exception.GuestError(original_message=_(
"Unable to delete database: %s.") % dbName)
else:
LOG.warning(_('Cannot delete a reserved database '
'%(db)s'), {'db': dbName})
def check_format(self, device_path):
try:
stdout, stderr = utils.execute("dumpe2fs",
device_path,
run_as_root=True,
root_helper="sudo")
if 'has_journal' not in stdout:
msg = _("Volume '%s' does not appear to be formatted.") % (
device_path)
raise exception.GuestError(original_message=msg)
except exception.ProcessExecutionError as pe:
if 'Wrong magic number' in pe.stderr:
volume_fstype = self.fstype
log_fmt = "'Device '%(dev)s' did not seem to be '%(type)s'."
exc_fmt = _("'Device '%(dev)s' did not seem to be '%(type)s'.")
log_and_raise(log_fmt, exc_fmt, {
'dev': device_path,
'type': volume_fstype
})
log_fmt = "Volume '%s' was not formatted."
exc_fmt = _("Volume '%s' was not formatted.")
log_and_raise(log_fmt, exc_fmt, device_path)
def mount_storage(self, storage_info):
fstab = path.join('/etc', 'fstab')
default_mount_options = ('rw,bg,hard,nointr,tcp,vers=3,timeo=600,'
'rsize=32768,wsize=32768,actimeo=0')
data_mount_options = ('user,tcp,rsize=32768,wsize=32768,hard,intr,'
'noac,nfsvers=3')
if storage_info['type'] == 'nfs':
sources = storage_info['data']
data = list()
if operating_system.exists(fstab):
data.append(operating_system.read_file(fstab, as_root=True))
def _line(source, target, options=default_mount_options):
data.append('{source} {target} nfs {options} 0 0'.format(
source=source, target=target, options=options))
_line(
sources['votedisk_mount'],
SHARED_DISK_PATHS['votedisk'],
)
_line(
sources['registry_mount'],
SHARED_DISK_PATHS['registry'],
)
_line(sources['database_mount'], SHARED_DISK_PATHS['database'],
data_mount_options)
operating_system.write_file(fstab, '\n'.join(data), as_root=True)
utils.execute_with_timeout('mount',
'-a',
run_as_root=True,
root_helper='sudo',
timeout=service.ORACLE_TIMEOUT,
log_output_on_error=True)
else:
raise exception.GuestError(
_("Storage type {t} not valid.").format(
t=storage_info['type']))
def log_and_raise(message):
LOG.exception(message)
raise_msg = message + _("\nExc: %s") % traceback.format_exc()
raise exception.GuestError(original_message=raise_msg)
def delete_user(self, user):
LOG.debug("Delete a given CouchDB user.")
couchdb_user = models.CouchDBUser.deserialize(user)
db_names = self.list_database_names()
for db in db_names:
userlist = []
try:
out, err = utils.execute_with_timeout(
system.DB_ACCESS_COMMAND %
{'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password,
'dbname': db},
shell=True)
except exception.ProcessExecutionError:
LOG.debug(
"Error while trying to get the users for database: %s.",
db)
continue
evalout = ast.literal_eval(out)
if evalout:
members = evalout['members']
names = members['names']
for i in range(0, len(names)):
couchdb_user.databases = db
userlist.append(names[i])
if couchdb_user.name in userlist:
userlist.remove(couchdb_user.name)
out2, err2 = utils.execute_with_timeout(
system.REVOKE_ACCESS_COMMAND % {
'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password,
'dbname': db,
'username': userlist},
shell=True)
try:
out2, err = utils.execute_with_timeout(
system.DELETE_REV_ID %
{'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password},
shell=True)
evalout2 = ast.literal_eval(out2)
rows = evalout2['rows']
userlist = []
for i in range(0, len(rows)):
row = rows[i]
username = "******" + couchdb_user.name
if row['key'] == username:
rev = row['value']
revid = rev['rev']
utils.execute_with_timeout(
system.DELETE_USER_COMMAND % {
'admin_name': self._admin_user().name,
'admin_password': self._admin_user().password,
'username': couchdb_user.name,
'revid': revid},
shell=True)
except exception.ProcessExecutionError as pe:
LOG.exception(_(
"There was an error while deleting user: %s."), pe)
raise exception.GuestError(original_message=_(
"Unable to delete user: %s.") % couchdb_user.name)