def start_pxc(self, my_extra=None): """ Start Percona XtraDB Cluster. This method will perform sanity checks for cluster startup :param my_extra: We can pass extra PXC startup option with this parameter """ # Start PXC cluster for replication test if my_extra is None: my_extra = '' dbconnection_check = db_connection.DbConnection( USER, WORKDIR + '/node1/mysql.sock') server_startup = pxc_startup.StartCluster(parent_dir, WORKDIR, BASEDIR, int(self.node), debug) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "PXC: Startup sanity check") if encryption == 'YES': result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "PXC: Configuration file creation") else: result = server_startup.create_config('none') utility_cmd.check_testcase(result, "PXC: Configuration file creation") result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "PXC: Initializing cluster") result = server_startup.add_myextra_configuration(cwd + '/replication.cnf') utility_cmd.check_testcase(result, "PXC: Adding custom configuration") result = server_startup.start_cluster(my_extra) utility_cmd.check_testcase(result, "PXC: Cluster startup") result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "PXC: Database connection")
def startup(self, wsrep_extra=None): # Start PXC cluster for upgrade test dbconnection_check = db_connection.DbConnection( USER, WORKDIR + '/node1/mysql.sock') server_startup = pxc_startup.StartCluster(parent_dir, WORKDIR, PXC_LOWER_BASE, int(NODE), debug) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "Startup sanity check") if encryption == 'YES': if wsrep_extra is not None: result = server_startup.create_config( 'encryption', 'gcache.keep_pages_size=5;' 'gcache.page_size=1024M;gcache.size=1024M;') else: result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "Configuration file creation") else: if wsrep_extra is not None: result = server_startup.create_config( 'none', 'gcache.keep_pages_size=5;' 'gcache.page_size=1024M;gcache.size=1024M;') else: result = server_startup.create_config('none') utility_cmd.check_testcase(result, "Configuration file creation") 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")
def start_ps(self, node, my_extra=None): """ Start Percona Server. This method will perform sanity checks for PS startup :param my_extra: We can pass extra PS startup option with this parameter """ if my_extra is None: my_extra = '' # Start PXC cluster for replication test dbconnection_check = db_connection.DbConnection(USER, PS1_SOCKET) server_startup = ps_startup.StartPerconaServer(parent_dir, WORKDIR, BASEDIR, int(node), debug) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "PS: Startup sanity check") if encryption == 'YES': result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "PS: Configuration file creation") else: result = server_startup.create_config() utility_cmd.check_testcase(result, "PS: Configuration file creation") result = server_startup.add_myextra_configuration(cwd + '/replication.cnf') utility_cmd.check_testcase(result, "PS: Adding custom configuration") result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "PS: Initializing cluster") result = server_startup.start_server(my_extra) utility_cmd.check_testcase(result, "PS: Cluster startup") result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "PS: Database connection")
def start_pxc(self, my_extra=None): """ Start Percona XtraDB Cluster. This method will perform sanity checks for cluster startup :param my_extra: We can pass extra PXC startup option with this parameter """ # Start PXC cluster for replication test if my_extra is None: my_extra = '' script_dir = os.path.dirname(os.path.realpath(__file__)) dbconnection_check = db_connection.DbConnection(user, node1_socket) server_startup = pxc_startup.StartCluster(parent_dir, workdir, basedir, int(self.node)) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "PXC: Startup sanity check") if encryption == 'YES': result = utility_cmd.create_ssl_certificate(workdir) utility_cmd.check_testcase(result, "PXC: SSL Configuration") result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "PXC: Configuration file creation") else: result = server_startup.create_config('none') utility_cmd.check_testcase(result, "PXC: Configuration file creation") result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "PXC: Initializing cluster") result = server_startup.add_myextra_configuration(script_dir + '/gtid_replication.cnf') utility_cmd.check_testcase(result, "PXC: Adding custom configuration") result = server_startup.start_cluster(my_extra) utility_cmd.check_testcase(result, "PXC: Cluster startup") result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "PXC: Database connection")
def start_pxc(self): # Start PXC cluster for pquery run 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") 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.initialize_cluster() utility_cmd.check_testcase(result, "Initializing cluster") result = server_startup.start_cluster('--max-connections=1500') utility_cmd.check_testcase(result, "Cluster startup") result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "Database connection") query = BASEDIR + "/bin/mysql --user=root --socket=" + \ WORKDIR + "/node1/mysql.sock -e'drop database if exists test " \ "; create database test ;' > /dev/null 2>&1" if debug == 'YES': print(query) query_status = os.system(query) if int(query_status) != 0: # return 1 print("ERROR!: Could not create test database.") exit(1)
def start_pxc(self): # Start PXC cluster for replication test dbconnection_check = db_connection.DbConnection( USER, WORKDIR + '/node1/mysql.sock') server_startup = pxc_startup.StartCluster(parent_dir, WORKDIR, BASEDIR, int(self.node), debug) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "Startup sanity check") if encryption == 'YES': result = server_startup.create_config( 'encryption', 'gcache.keep_pages_size=5;gcache.page_size=1024M;gcache.size=1024M;' ) utility_cmd.check_testcase(result, "Configuration file creation") else: result = server_startup.create_config( 'none', 'gcache.keep_pages_size=5;gcache.page_size=1024M;gcache.size=1024M;' ) utility_cmd.check_testcase(result, "Configuration file creation") 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")
def start_ps(self, node, my_extra=None): """ Start Percona Server. This method will perform sanity checks for PS startup :param my_extra: We can pass extra PS startup option with this parameter """ if my_extra is None: my_extra = '' # Start PXC cluster for replication test dbconnection_check = db_connection.DbConnection(user, ps1_socket) server_startup = ps_startup.StartPerconaServer(parent_dir, workdir, basedir, int(node)) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "PS: Startup sanity check") result = server_startup.create_config() utility_cmd.check_testcase(result, "PS: Configuration file creation") result = server_startup.add_myextra_configuration(cwd + '/replication.cnf') utility_cmd.check_testcase(result, "PS: Adding custom configuration") result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "PS: Initializing cluster") result = server_startup.start_server(my_extra) utility_cmd.check_testcase(result, "PS: Cluster startup") result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "PS: Database connection")
def startup(self): # Start PXC cluster for ChaosMonkey 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") 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.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")
def start_pxc(self): # Start PXC cluster for SSL test dbconnection_check = db_connection.DbConnection(USER, self.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") if encryption == 'YES': result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "Configuration file creation") else: result = server_startup.create_config('ssl') utility_cmd.check_testcase(result, "Configuration file creation") 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")
def start_pxc(self): # Start PXC cluster for replication test dbconnection_check = db_connection.DbConnection(user, self.socket) server_startup = pxc_startup.StartCluster(parent_dir, workdir, basedir, int(node)) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "Startup sanity check") result = utility_cmd.create_ssl_certificate(workdir) utility_cmd.check_testcase(result, "SSL Configuration") if encryption == 'YES': result = server_startup.create_config('encryption') utility_cmd.check_testcase(result, "Configuration file creation") else: result = server_startup.create_config('ssl') utility_cmd.check_testcase(result, "Configuration file creation") 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")
def start_pxc(self): # Start PXC cluster 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") # Check encryption run if encryption == 'YES': # Add encryption options 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") # Initialize cluster (create data directory) result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "Initializing cluster") # Start cluster result = server_startup.start_cluster('--max-connections=1500 ') utility_cmd.check_testcase(result, "Cluster startup") # Check DB connection result = dbconnection_check.connection_check() utility_cmd.check_testcase(result, "Database connection") # Create database test query = BASEDIR + "/bin/mysql --user=root --socket=" + \ WORKDIR + "/node1/mysql.sock -e'drop database if exists test " \ "; create database test ;' > /dev/null 2>&1" if debug == 'YES': print(query) query_status = os.system(query) if int(query_status) != 0: # return 1 print("ERROR!: Could not create test database.") exit(1) utility_cmd.check_testcase(0, "PXC connection string") for i in range(1, int(NODE) + 1): # Print connection string print('\t' + BASEDIR + '/bin/mysql --user=root --socket=' + WORKDIR + '/node' + str(i) + '/mysql.sock')
def start_pxc(self, parent_dir, workdir, basedir, node, socket, user, encryption, my_extra): # Start PXC cluster dbconnection_check = db_connection.DbConnection(user, socket) server_startup = pxc_startup.StartCluster(parent_dir, workdir, basedir, int(node), self.debug) result = server_startup.sanity_check() self.check_testcase(result, "Startup sanity check") if encryption == 'YES': result = server_startup.create_config('encryption') self.check_testcase(result, "Configuration file creation") else: result = server_startup.create_config('none') self.check_testcase(result, "Configuration file creation") result = server_startup.initialize_cluster() self.check_testcase(result, "Initializing cluster") result = server_startup.start_cluster('--max-connections=1500 ' + my_extra) self.check_testcase(result, "Cluster startup") result = dbconnection_check.connection_check() self.check_testcase(result, "Database connection")
def thread_pooling_qa(self, socket, db): # Thread Pooling QA thread_handling_option = [ 'pool-of-threads', 'one-thread-per-connection' ] thread_pool_size = [2, 4, 8] thread_pool_max_threads = [2, 4, 8] for tp_option, tp_size, tp_max_thread in \ itertools.product(thread_handling_option, thread_pool_size, thread_pool_max_threads): my_extra = "--thread_handling=" + tp_option + " --thread_pool_size=" + str(tp_size) + \ " --thread_pool_max_threads=" + str(tp_max_thread) # Start PXC cluster for encryption test utility_cmd.check_testcase(0, "Thread pooling options : " + my_extra) 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('none') utility_cmd.check_testcase(result, "Configuration file creation") result = server_startup.initialize_cluster() utility_cmd.check_testcase(result, "Initializing cluster") for i in range(1, int(NODE) + 1): n_name = open(WORKDIR + '/conf/node' + str(i) + '.cnf', 'a+') n_name.write('admin_address=127.0.0.1\n') n_name.write('admin_port=' + str(33062 + i) + '\n') n_name.close() 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") self.sysbench_run(WORKDIR + '/node1/mysql.sock', 'test', 33063) utility_cmd.stop_pxc(WORKDIR, BASEDIR, NODE)
def startup(self, replication_conf): # Start PXC cluster for upgrade test dbconnection_check = db_connection.DbConnection( USER, WORKDIR + '/node1/mysql.sock') server_startup = pxc_startup.StartCluster(parent_dir, WORKDIR, PXC_LOWER_BASE, int(NODE), debug) result = server_startup.sanity_check() utility_cmd.check_testcase(result, "Startup sanity check") 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.add_myextra_configuration( parent_dir + '/suite/replication/' + replication_conf) utility_cmd.check_testcase(result, "PXC: Adding custom configuration") 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")
def start_ps(self, parent_dir, workdir, basedir, node, socket, user, encryption, my_extra): """ Start Percona Server. This method will perform sanity checks for PS startup """ # Start PXC cluster for replication test dbconnection_check = db_connection.DbConnection(user, socket) server_startup = ps_startup.StartPerconaServer(parent_dir, workdir, basedir, int(node)) result = server_startup.sanity_check() self.check_testcase(result, "PS: Startup sanity check") if encryption == 'YES': result = server_startup.create_config('encryption') self.check_testcase(result, "PS: Configuration file creation") else: result = server_startup.create_config() self.check_testcase(result, "PS: Configuration file creation") result = server_startup.initialize_cluster() self.check_testcase(result, "PS: Initializing cluster") result = server_startup.start_server('--max-connections=1500 ' + my_extra) self.check_testcase(result, "PS: Cluster startup") result = dbconnection_check.connection_check() self.check_testcase(result, "PS: Database connection")
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)
utility_cmd.check_testcase(result, "Sample data load") print("------------------------------") print("PXC Random MySQLD options test") print("------------------------------") mysql_options = open(parent_dir + '/conf/mysql_options_pxc80.txt') for mysql_option in mysql_options: if os.path.exists(WORKDIR + '/random_mysql_error'): os.system('rm -rf ' + WORKDIR + '/random_mysql_error >/dev/null 2>&1') os.mkdir(WORKDIR + '/random_mysql_error') else: os.mkdir(WORKDIR + '/random_mysql_error') random_mysql_option_qa = RandomMySQLDOptionQA() # Start PXC cluster for random mysqld options QA 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") 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") cnf_name = open(WORKDIR + '/conf/custom.cnf', 'a+') cnf_name.write('\n') cnf_name.write(mysql_option) cnf_name.close()
import configparser import unittest import pxc_startup from util import db_connection config = configparser.ConfigParser() config.read('config.ini') config.sections() workdir = config['config']['workdir'] basedir = config['config']['basedir'] cluster = pxc_startup.StartCluster(workdir, basedir, 2) connection_check = db_connection.DbConnection('root', '/tmp/node1.sock') connection_check.connectioncheck() class TestStartup(unittest.TestCase): def test_sanitycheck(self): self.assertEqual(cluster.sanitycheck(), 0, 'work/base directory have some issues') print('PXC Sanity check') def test_initializecluster(self): self.assertIsNot(cluster.initializecluster(), 1, 'Could not initialize database directory. ' 'Please check error log') def test_startcluster(self): self.assertIsNot(cluster.startcluster(), 1, 'Could not start cluster, ' 'Please check error log')
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)