def replication_testcase(self, ps_node, master, slave, comment, master_socket, slave_socket):
if comment == "mtr":
self.start_pxc('--slave-parallel-workers=5')
self.start_ps(ps_node, '--slave-parallel-workers=5')
comment = 'none'
else:
self.start_pxc()
self.start_ps(ps_node)
if comment == "msr":
utility_cmd.invoke_replication(BASEDIR, PS1_SOCKET,
slave_socket, 'GTID', "for channel 'master1'")
utility_cmd.invoke_replication(BASEDIR, PS2_SOCKET,
slave_socket, 'GTID', "for channel 'master2'")
else:
utility_cmd.invoke_replication(BASEDIR, master_socket,
slave_socket, 'GTID', comment)
replication_run.sysbench_run(master_socket, 'sbtest', master)
replication_run.data_load('ps_dataload_db', master_socket, master)
rqg_dataload = rqg_datagen.RQGDataGen(BASEDIR, WORKDIR, USER, debug)
rqg_dataload.pxc_dataload(master_socket)
if comment == "msr":
utility_cmd.replication_io_status(BASEDIR, slave_socket, slave, 'master1')
utility_cmd.replication_sql_status(BASEDIR, slave_socket, slave, 'master1')
utility_cmd.replication_io_status(BASEDIR, slave_socket, slave, 'master2')
utility_cmd.replication_sql_status(BASEDIR, slave_socket, slave, 'master2')
else:
utility_cmd.replication_io_status(BASEDIR, slave_socket, slave, comment)
utility_cmd.replication_sql_status(BASEDIR, slave_socket, slave, comment)
utility_cmd.stop_pxc(WORKDIR, BASEDIR, NODE)
utility_cmd.stop_ps(WORKDIR, BASEDIR, ps_node)
if os.path.isfile(parent_dir + '/util/createsql.py'):
generate_sql = createsql.GenerateSQL('/tmp/dataload.sql', 1000)
generate_sql.OutFile()
generate_sql.CreateTable()
sys.stdout = sys.__stdout__
create_db = self.basedir + "/bin/mysql --user=root --socket=" + \
socket + ' -Bse"drop database if exists ' + db + \
';create database ' + db + ';" 2>&1'
result = os.system(create_db)
utility_cmd.check_testcase(result, "SSL QA sample DB creation")
data_load_query = self.basedir + "/bin/mysql --user=root --socket=" + \
socket + ' ' + db + ' -f < /tmp/dataload.sql >/dev/null 2>&1'
result = os.system(data_load_query)
utility_cmd.check_testcase(result, "SSL QA sample data load")
print("\nPXC SSL test")
print("--------------")
ssl_run = SSLCheck(basedir, workdir, user, node1_socket, node)
ssl_run.start_pxc()
ssl_run.sysbench_run(node1_socket, 'test')
ssl_run.data_load('pxc_dataload_db', node1_socket)
rqg_dataload = rqg_datagen.RQGDataGen(basedir, workdir, 'examples', user)
rqg_dataload.initiate_rqg('test', node1_socket)
result = utility_cmd.check_table_count(basedir, 'test', 'sbtest1', node1_socket, node2_socket)
utility_cmd.check_testcase(result, "SSL QA table test.sbtest1 checksum between nodes")
utility_cmd.check_testcase(result, "SSL QA table pxc_dataload_db.t1 checksum between nodes")
checksum = table_checksum.TableChecksum(pt_basedir, basedir, workdir, node, node1_socket)
checksum.sanity_check()
checksum.data_consistency('test,pxc_dataload_db')
socket + ' -Bse"drop database if exists ' + db + \
';create database ' + db + ';" 2>&1'
if debug == 'YES':
print(create_db)
result = os.system(create_db)
utility_cmd.check_testcase(result, "Sample DB creation")
data_load_query = self.basedir + "/bin/mysql --user=root --socket=" + \
socket + ' ' + db + ' -f < /tmp/dataload.sql >/dev/null 2>&1'
if debug == 'YES':
print(data_load_query)
result = os.system(data_load_query)
utility_cmd.check_testcase(result, "Sample data load")
print("\nPXC data consistency test between nodes")
print("----------------------------------------")
consistency_run = ConsistencyCheck(BASEDIR, WORKDIR, USER, WORKDIR + '/node1/mysql.sock', PT_BASEDIR, NODE)
rqg_dataload = rqg_datagen.RQGDataGen(BASEDIR, WORKDIR, USER, debug)
consistency_run.start_pxc()
consistency_run.sysbench_run(WORKDIR + '/node1/mysql.sock', 'test')
consistency_run.data_load('pxc_dataload_db', WORKDIR + '/node1/mysql.sock')
rqg_dataload.pxc_dataload(WORKDIR + '/node1/mysql.sock')
version = utility_cmd.version_check(BASEDIR)
time.sleep(5)
result = utility_cmd.check_table_count(BASEDIR, 'test', WORKDIR + '/node1/mysql.sock',
WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: test")
result = utility_cmd.check_table_count(BASEDIR, 'pxc_dataload_db', WORKDIR + '/node1/mysql.sock',
WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: pxc_dataload_db")
replication_run.sysbench_run(master_socket, 'sbtest', master)
replication_run.data_load('ps_dataload_db', master_socket, master)
rqg_dataload.initiate_rqg('rqg_test', master_socket)
if comment == "msr":
utility_cmd.replication_io_status(basedir, slave_socket, slave, 'master1')
utility_cmd.replication_sql_status(basedir, slave_socket, slave, 'master1')
utility_cmd.replication_io_status(basedir, slave_socket, slave, 'master2')
utility_cmd.replication_sql_status(basedir, slave_socket, slave, 'master2')
else:
utility_cmd.replication_io_status(basedir, slave_socket, slave, comment)
utility_cmd.replication_sql_status(basedir, slave_socket, slave, comment)
replication_run = SetupReplication(basedir, workdir, node)
rqg_dataload = rqg_datagen.RQGDataGen(basedir, workdir,
'replication', user)
print("\nGTID PXC Node as Master and PS node as Slave")
print("----------------------------------------------")
replication_run.replication_testcase('1', 'PXC', 'PS', 'none', node1_socket, ps1_socket)
print("\nGTID PXC Node as Slave and PS node as Master")
print("----------------------------------------------")
replication_run.replication_testcase('1', 'PS', 'PXC', 'none', ps1_socket, node1_socket)
if int(version) > int("050700"):
print("\nGTID PXC multi source replication")
print("-----------------------------------")
replication_run.replication_testcase('2', 'PS', 'PXC', 'msr', ps1_socket, node1_socket)
print("\nGTID PXC multi thread replication")
print("-----------------------------------")
replication_run.replication_testcase('1', 'PS', 'PXC', 'mtr', ps1_socket, node1_socket)
utility_cmd.check_testcase(
result,
"Starting cluster node" + str(i) + " after upgrade run")
self.startup_check(i)
query = pxc_lower_base + "/bin/mysqld --version 2>&1 | grep -oe '[0-9]\.[0-9][\.0-9]*' | head -n1"
lower_version = os.popen(query).read().rstrip()
query = pxc_upper_base + "/bin/mysqld --version 2>&1 | grep -oe '[0-9]\.[0-9][\.0-9]*' | head -n1"
upper_version = os.popen(query).read().rstrip()
print("\nPXC Upgrade test : Upgrading from PXC-" + lower_version + " to PXC-" +
upper_version)
print(
"------------------------------------------------------------------------------"
)
checksum = table_checksum.TableChecksum(pt_basedir, pxc_upper_base, workdir,
node, socket)
upgrade_qa = PXCUpgrade()
upgrade_qa.startup()
rqg_dataload = rqg_datagen.RQGDataGen(pxc_lower_base, workdir, 'galera', user)
rqg_dataload.initiate_rqg('rqg_galera', socket)
rqg_dataload = rqg_datagen.RQGDataGen(pxc_lower_base, workdir, 'transactions',
user)
rqg_dataload.initiate_rqg('rqg_transactions', socket)
rqg_dataload = rqg_datagen.RQGDataGen(pxc_lower_base, workdir, 'partitioning',
user)
rqg_dataload.initiate_rqg('rqg_partitioning', socket)
upgrade_qa.upgrade()
checksum.sanity_check()
checksum.data_consistency('test,rqg_galera,rqg_transactions,rqg_partitioning')
def encryption_qa(self):
# Encryption QA
# Create data insert procedure
rqg_dataload = rqg_datagen.RQGDataGen(BASEDIR, WORKDIR, USER)
encryption_tmp_ts = [
'innodb_temp_tablespace_encrypt=ON',
'innodb_temp_tablespace_encrypt=OFF'
]
encryption_bin_log = ['binlog_encryption=ON', 'binlog_encryption=OFF']
encryption_default_tbl = [
'default_table_encryption=ON', 'default_table_encryption=OFF'
]
encryption_redo_log = [
'innodb_redo_log_encrypt=ON', 'innodb_redo_log_encrypt=OFF'
]
encryption_undo_log = [
'innodb_undo_log_encrypt=ON', 'innodb_undo_log_encrypt=OFF'
]
encryption_sys_ts = [
'innodb_sys_tablespace_encrypt=ON',
'innodb_sys_tablespace_encrypt=OFF'
]
for encryption_tmp_ts_value, encryption_bin_log_value, encryption_default_tbl_value, \
encryption_redo_log_value, encryption_undo_log_value, encryption_sys_ts_value in \
itertools.product(encryption_tmp_ts, encryption_bin_log, encryption_default_tbl,
encryption_redo_log, encryption_undo_log, encryption_sys_ts):
encryption_combination = encryption_tmp_ts_value + " " + encryption_bin_log_value + \
" " + encryption_default_tbl_value + " " + encryption_redo_log_value + \
" " + encryption_undo_log_value + " " + encryption_sys_ts_value
utility_cmd.check_testcase(
0, "Encryption options : " + encryption_combination)
# Start PXC cluster for encryption test
dbconnection_check = db_connection.DbConnection(
USER, WORKDIR + '/node1/mysql.sock')
server_startup = pxc_startup.StartCluster(parent_dir,
WORKDIR, BASEDIR,
int(NODE), debug)
result = server_startup.sanity_check()
utility_cmd.check_testcase(result, "Startup sanity check")
result = server_startup.create_config('encryption')
utility_cmd.check_testcase(result, "Configuration file creation")
cnf_name = open(WORKDIR + '/conf/random_encryption.cnf', 'w+')
cnf_name.write('[mysqld]\n')
cnf_name.write("early-plugin-load=keyring_file.so" + '\n')
cnf_name.write("keyring_file_data=keyring" + '\n')
cnf_name.write(encryption_tmp_ts_value + '\n')
cnf_name.write(encryption_bin_log_value + '\n')
cnf_name.write(encryption_default_tbl_value + '\n')
cnf_name.write(encryption_redo_log_value + '\n')
cnf_name.write(encryption_undo_log_value + '\n')
cnf_name.write(encryption_sys_ts_value + '\n')
cnf_name.close()
for i in range(1, int(NODE) + 1):
os.system(
"sed -i 's#pxc_encrypt_cluster_traffic = OFF#pxc_encrypt_cluster_traffic = ON#g' "
+ WORKDIR + '/conf/node' + str(i) + '.cnf')
n_name = open(WORKDIR + '/conf/node' + str(i) + '.cnf', 'a+')
n_name.write('!include ' + WORKDIR +
'/conf/random_encryption.cnf\n')
n_name.close()
if encryption_sys_ts_value == "innodb_sys_tablespace_encrypt=ON":
init_extra = "--innodb_sys_tablespace_encrypt=ON " \
"--early-plugin-load=keyring_file.so " \
" --keyring_file_data=keyring"
result = server_startup.initialize_cluster(init_extra)
else:
result = server_startup.initialize_cluster()
utility_cmd.check_testcase(result, "Initializing cluster")
result = server_startup.start_cluster()
utility_cmd.check_testcase(result, "Cluster startup")
result = dbconnection_check.connection_check()
utility_cmd.check_testcase(result, "Database connection")
self.sysbench_run(WORKDIR + '/node1/mysql.sock', 'test')
rqg_dataload.pxc_dataload(WORKDIR + '/node1/mysql.sock')
# Add prepared statement SQLs
create_ps = BASEDIR + "/bin/mysql --user=root --socket=" + \
WORKDIR + '/node1/mysql.sock' + ' < ' + parent_dir + \
'/util/prepared_statements.sql > /dev/null 2>&1'
if debug == 'YES':
print(create_ps)
result = os.system(create_ps)
utility_cmd.check_testcase(result, "Creating prepared statements")
# Random data load
if os.path.isfile(parent_dir + '/util/createsql.py'):
generate_sql = createsql.GenerateSQL('/tmp/dataload.sql', 1000)
generate_sql.OutFile()
generate_sql.CreateTable()
sys.stdout = sys.__stdout__
data_load_query = BASEDIR + "/bin/mysql --user=root --socket=" + \
WORKDIR + '/node1/mysql.sock' + ' test -f < /tmp/dataload.sql >/dev/null 2>&1'
if debug == 'YES':
print(data_load_query)
result = os.system(data_load_query)
utility_cmd.check_testcase(result, "Sample data load")
utility_cmd.stop_pxc(WORKDIR, BASEDIR, NODE)
# Random dataload for consistency test
if os.path.isfile(parent_dir + '/util/createsql.py'):
generate_sql = createsql.GenerateSQL('/tmp/dataload.sql', 1000)
generate_sql.OutFile()
generate_sql.CreateTable()
sys.stdout = sys.__stdout__
create_db = self.basedir + "/bin/mysql --user=root --socket=" + \
socket + ' -Bse"drop database if exists ' + db + \
';create database ' + db + ';" 2>&1'
result = os.system(create_db)
utility_cmd.check_testcase(result, "Sample DB creation")
data_load_query = self.basedir + "/bin/mysql --user=root --socket=" + \
socket + ' ' + db + ' -f < /tmp/dataload.sql >/dev/null 2>&1'
result = os.system(data_load_query)
utility_cmd.check_testcase(result, "Sample data load")
print("\nPXC data consistency test between nodes")
print("----------------------------------------")
consistency_run = ConsistencyCheck(basedir, workdir, user, socket, pt_basedir,
node)
rqg_dataload = rqg_datagen.RQGDataGen(basedir, workdir, 'galera', user)
consistency_run.start_pxc()
consistency_run.sysbench_run(socket, 'test')
consistency_run.data_load('pxc_dataload_db', socket)
rqg_dataload.initiate_rqg('rqg_test', socket)
checksum = table_checksum.TableChecksum(pt_basedir, basedir, workdir, node,
socket)
checksum.sanity_check()
checksum.data_consistency('test,pxc_dataload_db,rqg_test')
print(
'------------------------------------------------------------------------------------'
)
print("\nPXC Upgrade test : Upgrading from PXC-" + lower_version + " to PXC-" +
upper_version)
print(
'------------------------------------------------------------------------------------'
)
print(datetime.now().strftime("%H:%M:%S ") +
" Rolling upgrade without active workload")
print(
'------------------------------------------------------------------------------------'
)
upgrade_qa = PXCUpgrade()
upgrade_qa.startup()
rqg_dataload = rqg_datagen.RQGDataGen(PXC_LOWER_BASE, WORKDIR, USER, debug)
rqg_dataload.pxc_dataload(WORKDIR + '/node1/mysql.sock')
upgrade_qa.rolling_upgrade('none')
print(
'------------------------------------------------------------------------------------'
)
print(datetime.now().strftime("%H:%M:%S ") +
" Rolling upgrade with active readonly workload")
print(
'------------------------------------------------------------------------------------'
)
upgrade_qa.startup()
rqg_dataload = rqg_datagen.RQGDataGen(PXC_LOWER_BASE, WORKDIR, USER, debug)
rqg_dataload.pxc_dataload(WORKDIR + '/node1/mysql.sock')
upgrade_qa.rolling_upgrade('readonly')
print(
