def read_module_results(cls, is_admin=False, include_contents=False):
"""Read all the module results on the guest and return a list
of them.
"""
results = []
pattern = cls.MODULE_RESULT_FILENAME
result_files = operating_system.list_files_in_directory(
cls.MODULE_BASE_DIR, recursive=True, pattern=pattern)
for result_file in result_files:
result = cls.read_module_result(result_file)
if (not result.get('removed')
and (is_admin or result.get('visible'))):
if include_contents:
codec = stream_codecs.Base64Codec()
if not is_admin and result.get('admin_only'):
contents = (
"Must be admin to retrieve contents for module %s"
% result.get('name', 'Unknown'))
result['contents'] = codec.serialize(contents)
else:
contents_dir = os.path.dirname(result_file)
contents_file = cls.build_contents_filename(
contents_dir)
result['contents'] = operating_system.read_file(
contents_file, codec=codec, decode=False)
results.append(result)
return results
def write_module_contents(cls, module_dir, contents, md5):
contents_file = cls.build_contents_filename(module_dir)
operating_system.write_file(contents_file,
contents,
codec=stream_codecs.Base64Codec(),
encode=False)
return contents_file
def get_master_ref(self, service, snapshot_info):
"""Capture information from a master node"""
pfile = '/tmp/init%s_stby.ora' % self._get_config().db_name
pwfile = ('%(ora_home)s/dbs/orapw%(db_name)s' % {
'ora_home': CONF.get(MANAGER).oracle_home,
'db_name': self._get_config().db_name
})
ctlfile = '/tmp/%s_stby.ctl' % self._get_config().db_name
oratabfile = '/etc/oratab'
oracnffile = CONF.get(MANAGER).conf_file
datafile = '/tmp/oradata.tar.gz'
def _cleanup_tmp_files():
operating_system.remove(ctlfile, force=True, as_root=True)
operating_system.remove(pfile, force=True, as_root=True)
operating_system.remove(datafile, force=True, as_root=True)
_cleanup_tmp_files()
with ora_service.LocalOracleClient(self._get_config().db_name,
service=True) as client:
client.execute("ALTER DATABASE CREATE STANDBY CONTROLFILE AS "
"'%s'" % ctlfile)
ora_service.OracleAdmin().create_parameter_file(target=pfile,
client=client)
q = sql_query.Query()
q.columns = ["value"]
q.tables = ["v$parameter"]
q.where = ["name = 'fal_server'"]
client.execute(str(q))
row = client.fetchone()
db_list = []
if row is not None and row[0] is not None:
db_list = str(row[0]).split(",")
db_list.insert(0, self._get_config().db_name)
# Create a tar file containing files needed for slave creation
utils.execute_with_timeout('tar',
'-Pczvf',
datafile,
ctlfile,
pwfile,
pfile,
oratabfile,
oracnffile,
run_as_root=True,
root_helper='sudo')
oradata_encoded = operating_system.read_file(
datafile,
codec=stream_codecs.Base64Codec(),
as_root=True,
decode=False)
_cleanup_tmp_files()
master_ref = {
'host': netutils.get_my_ipv4(),
'db_name': self._get_config().db_name,
'db_list': db_list,
'oradata': oradata_encoded,
}
return master_ref
def test_serialize_deserialize_base64codec(self):
random_data = bytearray(Random.new().read(12))
data = ['abc', 'numbers01234', random_data]
codec = stream_codecs.Base64Codec()
for datum in data:
serialized_data = codec.serialize(datum)
deserialized_data = codec.deserialize(serialized_data)
self.assertEqual(datum, deserialized_data,
"Serialize/Deserialize failed")
def test_serialize_deserialize_base64codec(self):
random_data = bytearray(os.urandom(12))
data = [b'abc',
b'numbers01234',
b'non-ascii:\xe9\xff',
random_data]
codec = stream_codecs.Base64Codec()
for datum in data:
serialized_data = codec.serialize(datum)
deserialized_data = codec.deserialize(serialized_data)
self. assertEqual(datum, deserialized_data,
"Serialize/Deserialize failed")
def get_master_ref(self, service, snapshot_info):
"""Capture information from a master node"""
ctlfile = path.join(TMP_DIR,
'%s_stby.ctl' % service.admin.database_name)
datafile = path.join(TMP_DIR, 'oradata.tar.gz')
def _cleanup_tmp_files():
operating_system.remove(ctlfile, force=True, as_root=True)
operating_system.remove(datafile, force=True, as_root=True)
_cleanup_tmp_files()
with service.cursor(service.admin.database_name) as cursor:
cursor.execute(
str(
sql_query.AlterDatabase(
"CREATE STANDBY CONTROLFILE AS '%s'" % ctlfile)))
cursor.execute(
str(
sql_query.Query(columns=['VALUE'],
tables=['V$PARAMETER'],
where=["NAME = 'fal_server'"])))
row = cursor.fetchone()
db_list = []
if row is not None and row[0] is not None:
db_list = str(row[0]).split(",")
db_list.insert(0, service.admin.database_name)
# Create a tar file containing files needed for slave creation
utils.execute_with_timeout('tar',
'-Pczvf',
datafile,
ctlfile,
service.paths.orapw_file,
service.paths.oratab_file,
CONF.get(MANAGER).conf_file,
run_as_root=True,
root_helper='sudo')
oradata_encoded = operating_system.read_file(
datafile,
codec=stream_codecs.Base64Codec(),
as_root=True,
decode=False)
_cleanup_tmp_files()
master_ref = {
'host': netutils.get_my_ipv4(),
'db_name': service.admin.database_name,
'db_list': db_list,
'oradata': oradata_encoded,
}
return master_ref
def prepare_slave(self, snapshot):
"""Prepare the environment needed for starting the slave Oracle
processes.
"""
master_info = snapshot['master']
db_name = master_info['db_name']
tmp_dir = '/tmp'
tmp_data_path = path.join(tmp_dir, 'oradata.tar.gz')
orabase_path = CONF.get(MANAGER).oracle_base
orahome_path = CONF.get(MANAGER).oracle_home
db_data_path = path.join(orabase_path, 'oradata', db_name)
fast_recovery_path = path.join(orabase_path, 'fast_recovery_area')
db_fast_recovery_path = path.join(fast_recovery_path, db_name)
audit_path = path.join(orabase_path, 'admin', db_name, 'adump')
admin_path = path.join(orabase_path, 'admin')
# Create necessary directories and set permissions
directories = [db_data_path, db_fast_recovery_path, audit_path]
for directory in directories:
operating_system.create_directory(directory,
system.ORACLE_INSTANCE_OWNER,
system.ORACLE_GROUP_OWNER,
as_root=True)
operating_system.chown(fast_recovery_path,
system.ORACLE_INSTANCE_OWNER,
system.ORACLE_GROUP_OWNER,
as_root=True)
operating_system.chown(admin_path,
system.ORACLE_INSTANCE_OWNER,
system.ORACLE_GROUP_OWNER,
as_root=True)
# Install on the slave files extracted from the master
# (e.g. the control, pfile, password, oracle.cnf file ... etc)
oradata = master_info['oradata']
operating_system.write_file(tmp_data_path,
oradata,
codec=stream_codecs.Base64Codec())
utils.execute_with_timeout('tar',
'-Pxzvf',
tmp_data_path,
run_as_root=True,
root_helper='sudo')
# Put the control file in place
tmp_ctlfile_path = path.join(tmp_dir, '%s_stby.ctl' % db_name)
ctlfile1_path = path.join(db_data_path, 'control01.ctl')
ctlfile2_path = path.join(db_fast_recovery_path, 'control02.ctl')
operating_system.move(tmp_ctlfile_path, ctlfile1_path, as_root=True)
operating_system.copy(ctlfile1_path,
ctlfile2_path,
preserve=True,
as_root=True)
db_unique_name = ('%(db_name)s_%(replica_label)s' % {
'db_name': db_name,
'replica_label': utils.generate_random_string(6)
})
# Customize the pfile for slave and put it in the right place.
# The pfile that came from master is owned by the 'oracle' user,
# so we need to change ownership first before editing it.
tmp_pfile_path = path.join(tmp_dir, 'init%s_stby.ora' % db_name)
pfile_path = path.join(orahome_path, 'dbs', 'init%s.ora' % db_name)
operating_system.chown(tmp_pfile_path,
getpass.getuser(),
None,
as_root=True)
with open(tmp_pfile_path, 'a') as pfile:
pfile.write("*.db_unique_name='%s'\n" % db_unique_name)
# Finished editing pfile, put it in the proper directory and chown
# back to oracle user and group
operating_system.move(tmp_pfile_path,
pfile_path,
force=True,
as_root=True)
operating_system.chown(pfile_path,
system.ORACLE_INSTANCE_OWNER,
system.ORACLE_GROUP_OWNER,
as_root=True)
self.ORA_CONF.db_name = db_name
self.ORA_CONF.db_unique_name = db_unique_name
# Set proper permissions on the oratab file
operating_system.chown('/etc/oratab',
system.ORACLE_INSTANCE_OWNER,
system.ORACLE_GROUP_OWNER,
as_root=True)
# Create the listener.ora file
self._create_lsnr_file()
# Restart the listener
utils.execute_with_timeout("sudo",
"su",
"-",
"oracle",
"-c",
"lsnrctl reload",
timeout=CONF.usage_timeout)
def decode_data(data):
return stream_codecs.Base64Codec().deserialize(data)
def encode_data(data):
if isinstance(data, six.text_type):
data = data.encode('utf-8')
return stream_codecs.Base64Codec().serialize(data)
def encode_data(data):
# NOTE(zhaochao) No need to encoding string object any more,
# as Base64Codec is now using oslo_serialization.base64 which
# could take care of this.
return stream_codecs.Base64Codec().serialize(data)
def prepare_slave(self, service, snapshot):
"""Prepare the environment needed for starting the slave Oracle
processes.
"""
master_info = snapshot['master']
db_name = master_info['db_name']
db_unique_name = ('%(db_name)s_%(replica_label)s' % {
'db_name': db_name,
'replica_label': utils.generate_random_string(6)
})
service.paths.update_db_name(db_name)
# Create necessary directories and set necessary permissions
new_dirs = [
service.paths.db_data_dir, service.paths.db_fast_recovery_logs_dir,
service.paths.db_fast_recovery_dir, service.paths.audit_dir
]
for directory in new_dirs:
operating_system.create_directory(directory,
service.instance_owner,
service.instance_owner_group,
as_root=True)
chown_dirs = [
service.paths.fast_recovery_area, service.paths.admin_dir
]
for directory in chown_dirs:
operating_system.chown(directory,
service.instance_owner,
service.instance_owner_group,
as_root=True)
# Install on the slave files extracted from the master
# (e.g. the control, pfile, password, oracle.cnf file ... etc)
oradata_encoded = master_info['oradata']
tmp_data_path = path.join(TMP_DIR, 'oradata.tar.gz')
operating_system.write_file(tmp_data_path,
oradata_encoded,
codec=stream_codecs.Base64Codec(),
encode=False)
utils.execute_with_timeout('tar',
'-Pxzvf',
tmp_data_path,
run_as_root=True,
root_helper='sudo')
# Put the control file in place
tmp_ctlfile_path = path.join(TMP_DIR, '%s_stby.ctl' % db_name)
operating_system.move(tmp_ctlfile_path,
service.paths.ctlfile1_file,
as_root=True)
operating_system.copy(service.paths.ctlfile1_file,
service.paths.ctlfile2_file,
preserve=True,
as_root=True)
# Set the db_name and db_unique_name via the PFILE which will be
# removed later
operating_system.write_file(service.paths.pfile,
"*.db_unique_name='%s'\n"
"*.db_name='%s'\n" %
(db_unique_name, db_name),
as_root=True)
operating_system.chown(service.paths.pfile,
service.instance_owner,
service.instance_owner_group,
as_root=True,
force=True)
service.admin.delete_conf_cache()
service.admin.ora_config.db_name = db_name
service.admin.ora_config.db_unique_name = db_unique_name
# Set proper permissions on the oratab file
operating_system.chown(service.paths.oratab_file,
service.instance_owner,
service.instance_owner_group,
as_root=True,
force=True)
# Create the listener.ora file and restart
service.configure_listener()
