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)