def sysbench_run(self, node1_socket, db, upgrade_type):
# Sysbench dataload for consistency test
sysbench_node1 = sysbench_run.SysbenchRun(PXC_LOWER_BASE, WORKDIR,
node1_socket, debug)
result = sysbench_node1.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench_node1.sysbench_load(db, SYSBENCH_TABLE_COUNT,
SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE)
utility_cmd.check_testcase(result, "Sysbench data load")
version = utility_cmd.version_check(PXC_LOWER_BASE)
if int(version) > int("050700"):
if encryption == 'YES':
for i in range(1, int(SYSBENCH_TABLE_COUNT) + 1):
encrypt_table = PXC_LOWER_BASE + '/bin/mysql --user=root ' \
'--socket=' + WORKDIR + '/node1/mysql.sock -e "' \
' alter table ' + db + '.sbtest' + str(i) + \
" encryption='Y'" \
'"; > /dev/null 2>&1'
if debug == 'YES':
print(encrypt_table)
os.system(encrypt_table)
sysbench_node2 = sysbench_run.SysbenchRun(
PXC_LOWER_BASE, WORKDIR, WORKDIR + '/node2/mysql.sock', debug)
sysbench_node3 = sysbench_run.SysbenchRun(
PXC_LOWER_BASE, WORKDIR, WORKDIR + '/node3/mysql.sock', debug)
if upgrade_type == 'readwrite' or upgrade_type == 'readwrite_sst':
result = sysbench_node1.sysbench_oltp_read_write(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(result,
"Initiated sysbench oltp run on node1")
result = sysbench_node2.sysbench_oltp_read_write(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(result,
"Initiated sysbench oltp run on node2")
result = sysbench_node3.sysbench_oltp_read_write(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(result,
"Initiated sysbench oltp run on node3")
elif upgrade_type == 'readonly':
result = sysbench_node1.sysbench_oltp_read_only(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(
result, "Initiated sysbench readonly run on node1")
result = sysbench_node2.sysbench_oltp_read_only(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(
result, "Initiated sysbench readonly run on node2")
result = sysbench_node3.sysbench_oltp_read_only(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 1000, 'Yes')
utility_cmd.check_testcase(
result, "Initiated sysbench readonly run on node3")
def sysbench_run(self, socket, db):
# Sysbench load test
threads = [32, 64, 128, 256, 1024]
version = utility_cmd.version_check(BASEDIR)
checksum = ""
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
for thread in threads:
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket,
debug)
if thread == 32:
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_cleanup(db, thread, thread,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result,
"Sysbench data cleanup (threads : " + str(thread) + ")")
result = sysbench.sysbench_load(db, thread, thread,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result, "Sysbench data load (threads : " + str(thread) + ")")
time.sleep(5)
result = utility_cmd.check_table_count(
BASEDIR, db, socket, WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: test")
def sysbench_run(self, socket, db):
# Sysbench dataload for consistency test
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR,
WORKDIR + '/node1/mysql.sock',
debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load(db, SYSBENCH_TABLE_COUNT,
SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE)
utility_cmd.check_testcase(result, "Sysbench data load")
if encryption == 'YES':
for i in range(1, int(SYSBENCH_TABLE_COUNT) + 1):
encrypt_table = BASEDIR + '/bin/mysql --user=root ' \
'--socket=' + socket + ' -e "' \
' alter table ' + db + '.sbtest' + str(i) + \
" encryption='Y'" \
'"; > /dev/null 2>&1'
if debug == 'YES':
print(encrypt_table)
os.system(encrypt_table)
result = sysbench.sysbench_oltp_read_write(db, SYSBENCH_TABLE_COUNT,
SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE,
SYSBENCH_RUN_TIME, 'Yes')
utility_cmd.check_testcase(result, "Initiated sysbench oltp run")
def sysbench_run(self, socket, db):
checksum = ""
# Sysbench load test
tables = [50, 100, 300, 600, 1000]
threads = [32, 64, 128, 256, 512, 1024]
version = utility_cmd.version_check(BASEDIR)
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
for table_count in tables:
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_cleanup(
db, table_count, table_count, SYSBENCH_RANDOM_LOAD_TABLE_SIZE)
utility_cmd.check_testcase(
result,
"Sysbench data cleanup (threads : " + str(table_count) + ")")
result = sysbench.sysbench_load(db, table_count, table_count,
SYSBENCH_RANDOM_LOAD_TABLE_SIZE)
utility_cmd.check_testcase(
result,
"Sysbench data load (threads : " + str(table_count) + ")")
for thread in threads:
sysbench.sysbench_oltp_read_write(
db, table_count, thread, SYSBENCH_RANDOM_LOAD_TABLE_SIZE,
SYSBENCH_RANDOM_LOAD_RUN_TIME)
time.sleep(5)
result = utility_cmd.check_table_count(
BASEDIR, db, socket, WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result,
"Checksum run for DB: " + db)
def sysbench_run(self, socket, db, port):
# Sysbench data load
version = utility_cmd.version_check(BASEDIR)
checksum = ""
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load(db, 50, 50, SYSBENCH_NORMAL_TABLE_SIZE)
utility_cmd.check_testcase(
result,
"Sysbench data load (threads : " + str(SYSBENCH_THREADS) + ")")
# Sysbench OLTP read write run
query = "sysbench /usr/share/sysbench/oltp_read_write.lua" \
" --table-size=" + str(SYSBENCH_NORMAL_TABLE_SIZE) + \
" --tables=" + str(50) + \
" --threads=" + str(50) + \
" --mysql-db=test --mysql-user="******" --mysql-password="******" --db-driver=mysql --mysql-host=127.0.0.1 --mysql-port=" + str(port) + \
" --time=300 --db-ps-mode=disable run > " + WORKDIR + "/log/sysbench_read_write.log"
if debug == 'YES':
print(query)
query_status = os.system(query)
if int(query_status) != 0:
print("ERROR!: sysbench read write run is failed")
utility_cmd.check_testcase(result, "Sysbench read write run")
utility_cmd.check_testcase(0, "Sysbench read write run")
def sysbench_run(self, socket, db):
sysbench = sysbench_run.SysbenchRun(basedir, workdir,
sysbench_user, sysbench_pass,
socket, sysbench_threads,
sysbench_table_size, db,
sysbench_threads, sysbench_run_time)
result = sysbench.sanity_check()
utility_cmd.check_testcase(result, "SSL QA sysbench run sanity check")
result = sysbench.sysbench_load()
utility_cmd.check_testcase(result, "SSL QA sysbench data load")
def sysbench_run(self, socket, db):
# Sysbench dataload for consistency test
sysbench = sysbench_run.SysbenchRun(pxc_lower_base, workdir,
sysbench_user, sysbench_pass,
socket, sysbench_threads,
sysbench_table_size, db,
sysbench_threads,
sysbench_run_time)
result = sysbench.sanity_check()
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load()
utility_cmd.check_testcase(result, "Sysbench data load")
def sysbench_run(self, socket, db):
# Sysbench dataload for consistency test
sysbench = sysbench_run.SysbenchRun(basedir, workdir, sysbench_user,
sysbench_pass, socket,
sysbench_threads,
sysbench_table_size, db,
sysbench_threads,
sysbench_run_time)
result = sysbench.sanity_check()
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load()
utility_cmd.check_testcase(result, "Sysbench data load")
result = sysbench.sysbench_oltp_read_write()
utility_cmd.check_testcase(result, "Initiated sysbench oltp run")
def sysbench_run(self, socket, db):
# Sysbench load test
threads = [32, 64, 128]
version = utility_cmd.version_check(BASEDIR)
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_custom_table(
db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_CUSTOMIZED_DATALOAD_TABLE_SIZE)
utility_cmd.check_testcase(result, "Sysbench data load")
def sysbench_run(self, socket, db, node):
# Sysbench data load
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR,
socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, node + ": Replication QA sysbench run sanity check")
result = sysbench.sysbench_load(db, SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS, SYSBENCH_NORMAL_TABLE_SIZE)
utility_cmd.check_testcase(result, node + ": Replication QA sysbench data load")
if encryption == 'YES':
for i in range(1, int(SYSBENCH_TABLE_COUNT) + 1):
encrypt_table = BASEDIR + '/bin/mysql --user=root ' \
'--socket=' + socket + ' -e "' \
' alter table ' + db + '.sbtest' + str(i) + \
" encryption='Y'" \
'"; > /dev/null 2>&1'
if debug == 'YES':
print(encrypt_table)
os.system(encrypt_table)
def sysbench_run(self, socket, db):
# Sysbench data load
version = utility_cmd.version_check(BASEDIR)
checksum = ""
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load(db, SYSBENCH_TABLE_COUNT,
SYSBENCH_THREADS,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result,
"Sysbench data load (threads : " + str(SYSBENCH_THREADS) + ")")
def sysbench_run(self, socket, db):
# Sysbench load test
threads = [32, 64, 128]
version = utility_cmd.version_check(BASEDIR)
if int(version) < int("080000"):
checksum = table_checksum.TableChecksum(PT_BASEDIR, BASEDIR,
WORKDIR, NODE, socket,
debug)
checksum.sanity_check()
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
for thread in threads:
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
sysbench.sysbench_custom_read_qa(db, 5, thread,
SYSBENCH_READ_QA_TABLE_SIZE)
time.sleep(5)
result = utility_cmd.check_table_count(
BASEDIR, db, socket, WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: " + db)
def sysbench_run(self, socket, db):
# Sysbench load test
threads = [32, 64, 128, 256, 1024]
checksum = table_checksum.TableChecksum(pt_basedir, basedir, workdir,
node, socket)
checksum.sanity_check()
for thread in threads:
sysbench = sysbench_run.SysbenchRun(basedir, workdir,
sysbench_user, sysbench_pass,
socket, thread,
sysbench_table_size, db,
thread, sysbench_run_time)
if thread == 32:
result = sysbench.sanity_check()
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_cleanup()
utility_cmd.check_testcase(
result,
"Sysbench data cleanup (threads : " + str(thread) + ")")
result = sysbench.sysbench_load()
utility_cmd.check_testcase(
result, "Sysbench data load (threads : " + str(thread) + ")")
checksum.data_consistency('test')
def data_load(self, socket, db):
# Sysbench data load
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load(db, 10, 10, SYSBENCH_NORMAL_TABLE_SIZE)
utility_cmd.check_testcase(result, "Sysbench data load")
# Add prepared statement SQLs
create_ps = BASEDIR + "/bin/mysql --user=root --socket=" + \
socket + ' < ' + parent_dir + '/util/prepared_statements.sql > /dev/null 2>&1'
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=" + \
socket + ' ' + db + ' -f < /tmp/dataload.sql >/dev/null 2>&1'
result = os.system(data_load_query)
utility_cmd.check_testcase(result, "Sample data load")
def start_random_test(self, socket, db):
my_extra = "--innodb_buffer_pool_size=8G --innodb_log_file_size=1G"
dbconnection_check = db_connection.DbConnection(USER, socket)
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.initialize_cluster()
utility_cmd.check_testcase(result, "Initializing cluster")
if encryption == 'YES':
result = server_startup.create_config('encryption')
utility_cmd.check_testcase(result, "Configuration file creation")
else:
result = server_startup.create_config('none')
utility_cmd.check_testcase(result, "Configuration file creation")
result = server_startup.start_cluster(my_extra)
utility_cmd.check_testcase(result, "Cluster startup")
result = dbconnection_check.connection_check()
utility_cmd.check_testcase(result, "Database connection")
# Sysbench load test
sysbench = sysbench_run.SysbenchRun(BASEDIR, WORKDIR, socket, debug)
result = sysbench.sanity_check(db)
utility_cmd.check_testcase(result, "Sysbench run sanity check")
result = sysbench.sysbench_load(db, 64, 64,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(result, "Sysbench data load")
utility_cmd.stop_pxc(WORKDIR, BASEDIR, NODE)
wsrep_provider_options = {
"gcache.keep_pages_size": [0, 1, 2],
"gcache.recover": ["yes", "no"],
"gcache.page_size": ["512M", "1024M"],
"gcache.size": ["512M", "1024M", "2048M"],
#"repl.commit_order": [0, 1, 2, 3]
}
keys = wsrep_provider_options.keys()
values = (wsrep_provider_options[key] for key in keys)
wsrep_combinations = [
dict(zip(keys, combination))
for combination in itertools.product(*values)
]
wsrep_provider_option = ''
for wsrep_combination in range(0, len(wsrep_combinations)):
for wsrep_option, wsrep_value in wsrep_combinations[
wsrep_combination].items():
wsrep_provider_option += wsrep_option + "=" + str(
wsrep_value) + ";"
print(datetime.now().strftime("%H:%M:%S ") +
" WSREP Provider combination(" + wsrep_provider_option + ")")
if encryption == 'YES':
result = server_startup.create_config('encryption',
wsrep_provider_option)
utility_cmd.check_testcase(result,
"Updated configuration file")
else:
result = server_startup.create_config('none',
wsrep_provider_option)
utility_cmd.check_testcase(result,
"Updated configuration file")
result = server_startup.start_cluster()
utility_cmd.check_testcase(result, "Cluster startup")
result = dbconnection_check.connection_check()
utility_cmd.check_testcase(result, "Database connection check")
result = sysbench.sysbench_oltp_read_write(
db, 64, 64, SYSBENCH_LOAD_TEST_TABLE_SIZE, 300, 'Yes')
utility_cmd.check_testcase(result, "Sysbench oltp run initiated")
query = 'pidof sysbench'
sysbench_pid = os.popen(query).read().rstrip()
time.sleep(100)
shutdown_node = BASEDIR + '/bin/mysqladmin --user=root --socket=' + \
WORKDIR + '/node3/mysql.sock shutdown > /dev/null 2>&1'
if debug == 'YES':
print(shutdown_node)
result = os.system(shutdown_node)
utility_cmd.check_testcase(
result, "Shutdown cluster node for IST/SST check")
time.sleep(5)
kill_sysbench = "kill -9 " + sysbench_pid
if debug == 'YES':
print("Terminating sysbench run : " + kill_sysbench)
os.system(kill_sysbench)
self.startup_check(3)
wsrep_provider_option = ''
time.sleep(5)
result = utility_cmd.check_table_count(
BASEDIR, db, socket, WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: test")
utility_cmd.stop_pxc(WORKDIR, BASEDIR, NODE)
def rolling_upgrade(self, upgrade_type):
""" This function will upgrade
Percona XtraDB Cluster to
latest version and perform
table checksum.
"""
self.sysbench_run(WORKDIR + '/node1/mysql.sock', 'test', upgrade_type)
time.sleep(5)
for i in range(int(NODE), 0, -1):
query = "ps -ef | grep sysbench | grep -v gep | grep node" + \
str(i) + " | awk '{print $2}'"
sysbench_pid = os.popen(query).read().rstrip()
kill_sysbench = "kill -9 " + sysbench_pid + " > /dev/null 2>&1"
if debug == 'YES':
print("Terminating sysbench run : " + kill_sysbench)
os.system(kill_sysbench)
shutdown_node = PXC_LOWER_BASE + '/bin/mysqladmin --user=root --socket=' + \
WORKDIR + '/node' + str(i) + \
'/mysql.sock shutdown > /dev/null 2>&1'
if debug == 'YES':
print(shutdown_node)
result = os.system(shutdown_node)
utility_cmd.check_testcase(
result,
"Shutdown cluster node" + str(i) + " for upgrade testing")
if i == 3:
if upgrade_type == 'readwrite_sst':
sysbench_node1 = sysbench_run.SysbenchRun(
PXC_LOWER_BASE, WORKDIR, WORKDIR + '/node1/mysql.sock',
debug)
sysbench_node1.sanity_check('test_one')
sysbench_node1.sanity_check('test_two')
sysbench_node1.sanity_check('test_three')
result = sysbench_node1.sysbench_load(
'test_one', SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result, "Sysbench data load(DB: test_one)")
result = sysbench_node1.sysbench_load(
'test_two', SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result, "Sysbench data load(DB: test_two)")
result = sysbench_node1.sysbench_load(
'test_three', SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_LOAD_TEST_TABLE_SIZE)
utility_cmd.check_testcase(
result, "Sysbench data load(DB: test_three)")
version = utility_cmd.version_check(PXC_UPPER_BASE)
if int(version) > int("080000"):
os.system("sed -i '/wsrep_sst_auth=root:/d' " + WORKDIR +
'/conf/node' + str(i) + '.cnf')
os.system(
"sed -i 's#wsrep_slave_threads=8#wsrep_slave_threads=30#g' "
+ WORKDIR + '/conf/node' + str(i) + '.cnf')
startup_cmd = PXC_UPPER_BASE + '/bin/mysqld --defaults-file=' + \
WORKDIR + '/conf/node' + str(i) + '.cnf --datadir=' + \
WORKDIR + '/node' + str(i) + ' --basedir=' + PXC_UPPER_BASE + \
' --wsrep-provider=' + PXC_UPPER_BASE + \
'/lib/libgalera_smm.so --log-error=' + \
WORKDIR + '/log/upgrade_node' + str(i) + '.err >> ' + \
WORKDIR + '/log/upgrade_node' + str(i) + '.err 2>&1 &'
else:
startup_cmd = PXC_UPPER_BASE + '/bin/mysqld --defaults-file=' + \
WORKDIR + '/conf/node' + str(i) + '.cnf --datadir=' + \
WORKDIR + '/node' + str(i) + ' --basedir=' + PXC_UPPER_BASE + \
' --wsrep-provider=none --log-error=' + \
WORKDIR + '/log/upgrade_node' + str(i) + '.err >> ' + \
WORKDIR + '/log/upgrade_node' + str(i) + '.err 2>&1 &'
if debug == 'YES':
print(startup_cmd)
os.system(startup_cmd)
self.startup_check(i)
if int(version) < int("080000"):
upgrade_cmd = PXC_UPPER_BASE + '/bin/mysql_upgrade -uroot --socket=' + \
WORKDIR + '/node' + str(i) + \
'/mysql.sock > ' + WORKDIR + '/log/node' + str(i) + '_upgrade.log 2>&1'
if debug == 'YES':
print(upgrade_cmd)
result = os.system(upgrade_cmd)
utility_cmd.check_testcase(
result, "Cluster node" + str(i) + " upgrade is successful")
shutdown_node = PXC_UPPER_BASE + '/bin/mysqladmin --user=root --socket=' + \
WORKDIR + '/node' + str(i) + \
'/mysql.sock shutdown > /dev/null 2>&1'
if debug == 'YES':
print(shutdown_node)
result = os.system(shutdown_node)
utility_cmd.check_testcase(
result,
"Shutdown cluster node" + str(i) + " after upgrade run")
create_startup = 'sed "s#' + PXC_LOWER_BASE + '#' + PXC_UPPER_BASE + \
'#g" ' + WORKDIR + '/log/startup' + str(i) + '.sh > ' + \
WORKDIR + '/log/upgrade_startup' + str(i) + '.sh'
if debug == 'YES':
print(create_startup)
os.system(create_startup)
if i == 1:
remove_bootstrap_option = 'sed -i "s#--wsrep-new-cluster##g" ' + \
WORKDIR + '/log/upgrade_startup' + str(i) + '.sh'
if debug == 'YES':
print(remove_bootstrap_option)
os.system(remove_bootstrap_option)
time.sleep(5)
upgrade_startup = "bash " + WORKDIR + \
'/log/upgrade_startup' + str(i) + '.sh'
if debug == 'YES':
print(upgrade_startup)
result = os.system(upgrade_startup)
utility_cmd.check_testcase(
result,
"Starting cluster node" + str(i) + " after upgrade run")
self.startup_check(i)
time.sleep(10)
sysbench_node = sysbench_run.SysbenchRun(PXC_LOWER_BASE, WORKDIR,
WORKDIR + '/node1/mysql.sock',
debug)
result = sysbench_node.sysbench_oltp_read_write(
'test', SYSBENCH_TABLE_COUNT, SYSBENCH_THREADS,
SYSBENCH_NORMAL_TABLE_SIZE, 100)
utility_cmd.check_testcase(result, "Sysbench oltp run after upgrade")
time.sleep(5)
result = utility_cmd.check_table_count(PXC_UPPER_BASE, '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(PXC_UPPER_BASE, 'db_galera',
WORKDIR + '/node1/mysql.sock',
WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result, "Checksum run for DB: db_galera")
result = utility_cmd.check_table_count(PXC_UPPER_BASE,
'db_transactions',
WORKDIR + '/node1/mysql.sock',
WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result,
"Checksum run for DB: db_transactions")
result = utility_cmd.check_table_count(PXC_UPPER_BASE,
'db_partitioning',
WORKDIR + '/node1/mysql.sock',
WORKDIR + '/node2/mysql.sock')
utility_cmd.check_testcase(result,
"Checksum run for DB: db_partitioning")
utility_cmd.stop_pxc(WORKDIR, PXC_UPPER_BASE, NODE)
