def setup(self): self.server1 = self.servers.get_server(0) data_file = os.path.normpath("./std_data/fkeys.sql") self.drop_all() self.server1.disable_foreign_key_checks(True) try: res = self.server1.read_and_exec_SQL(data_file, self.debug) except UtilError, e: raise MUTLibError("Failed to read commands from file %s: %s" % \ (data_file, e.errmsg))
def check_prerequisites(self): if self.servers.get_server(0).check_version_compat(5, 6, 5): raise MUTLibError("Test requires server version prior to 5.6.5") # Need at least one server. self.server1 = None self.server2 = None self.need_server = False if not self.check_num_servers(3): self.need_server = True return self.check_num_servers(1)
def setup(self): num_server = self.servers.num_servers() if self.need_servers: try: self.servers.spawn_new_servers(2) except MUTLibError as err: raise MUTLibError("Cannot spawn needed servers: {0}".format( err.errmsg)) else: num_server -= 1 # Get last server in list self.server1 = self.servers.get_server(num_server) data_file = os.path.normpath("./std_data/basic_data.sql") self.drop_all() try: self.server1.read_and_exec_SQL(data_file, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: " "{1}".format(data_file, err.errmsg)) return True
def setup(self): self.server1 = self.servers.get_server(0) data_file = os.path.normpath("./std_data/basic_data.sql") self.drop_all() try: self.server1.read_and_exec_SQL(data_file, self.debug) except MUTLibError, err: raise MUTLibError( "Failed to read commands from file {0}{1}: ".format( data_file, err.errmsg))
def setup(self): self.res_fname = "result.txt" # Spawn servers self.server0 = self.servers.get_server(0) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server1 = self.servers.spawn_server("rep_master_gtid", mysqld, True) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server2 = self.servers.spawn_server("rep_slave1_gtid", mysqld, True) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server3 = self.servers.spawn_server("rep_slave2_gtid", mysqld, True) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server4 = self.servers.spawn_server("rep_slave3_gtid", mysqld, True) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server5 = self.servers.spawn_server("rep_slave4_gtid", mysqld, True) # Reset spawned servers (clear binary log and GTID_EXECUTED set) self.reset_master([self.server1, self.server2, self.server3, self.server4, self.server5]) self.m_port = self.server1.port self.s1_port = self.server2.port self.s2_port = self.server3.port self.s3_port = self.server4.port self.s4_port = self.server5.port rpl_admin.test.reset_topology(self) build_str = self.build_connection_string self.master_conn = build_str(self.server1).strip(' ') self.slave1_conn = build_str(self.server2).strip(' ') self.slave2_conn = build_str(self.server3).strip(' ') self.slave3_conn = build_str(self.server4).strip(' ') self.slave4_conn = build_str(self.server5).strip(' ') try: self.server5.exec_query("STOP SLAVE") self.server5.exec_query("RESET SLAVE") except UtilError: raise MUTLibError("Unable to reset slave") cmd = " ".join(["mysqlreplicate.py --rpl-user=rpl:rpl ", " --slave={0}".format(self.slave4_conn), " --master={0}".format(self.master_conn)]) self.exec_util(cmd, self.res_fname) self.servers_list = [self.server1, self.server2, self.server3, self.server4, self.server5] return True
def run(self): cmd_base = 'mysqlgrants.py --server={0}'.format( self.build_connection_string(self.server1)) test_num = 1 comment = ("Test case {0} - Privileges are inherited from global " "level to db level and from db level to tables and " "routines".format(test_num)) cmd = ("{0} util_test util_test.t3 util_test.t2 util_test.p1 " "util_test.f1".format(cmd_base)) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) test_num += 1 comment = ("Test case {0} - show grantees, using all types of objects:" " tables, databases and stored routines".format(test_num)) if os.name == 'posix': cmd_arg = ("'`db``:db`' '`db``:db`.```t``.``export_2`' " "'`db``:db`.`fu``nc`' '`db``:db`.`pr````oc`' ") else: cmd_arg = ('"`db``:db`" "`db``:db`.```t``.``export_2`" ' '"`db``:db`.`fu``nc`" "`db``:db`.`pr````oc`" ') cmd = ("{0} util_test util_test.t1 util_test.t2 " "util_test.does_not_exist util_test.v1 db_does_not_exist " "util_test.t3 {1}".format(cmd_base, cmd_arg)) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) test_num += 1 comment = ("Test case {0} - show grants for all objects of a " "database using wildcard".format(test_num)) cmd = "{0} util_test.* ".format(cmd_base,) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # mask non deterministic output self.do_masks() return True
def setup(self): super(test, self).setup() rows = self.server2.exec_query("SHOW VARIABLES LIKE 'datadir'") if not rows: raise MUTLibError("Unable to determine datadir of cloned server " "at {0}:{1}".format(self.server2.host, self.server2.port)) self.server2_datadir = rows[0][1] return True
def check_prerequisites(self): # Check MySQL server version - Must be 5.1.0 or higher if not self.servers.get_server(0).check_version_compat(5, 1, 0): raise MUTLibError("Test requires server version 5.1.0 or higher") self.check_gtid_unsafe() # Need at least one server. self.server1 = None self.need_servers = False if not self.check_num_servers(3): self.need_servers = True return self.check_num_servers(1)
def setup(self): self.server1 = self.servers.get_server(0) data_file = os.path.normpath("./std_data/basic_data.sql") self.drop_all() try: res = self.server1.read_and_exec_SQL(data_file, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file %s: %s" % (data_file, err.errmsg)) # Create backtick database (with weird names) data_file_backticks = os.path.normpath("./std_data/backtick_data.sql") try: res = self.server1.read_and_exec_SQL(data_file_backticks, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file %s: %s" % (data_file_backticks, err.errmsg)) return True
def setup(self): mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port(), "") self.server1 = self.servers.spawn_server("compare_db_srv1_aq_mix", mysqld, True) if self.server1.select_variable("SQL_MODE") == "ANSI_QUOTES": raise MUTLibError("This Test needs a server with SQL_MODE != " "ANSI_QUOTES {0}:{1}".format( self.server2.host, self.server2.port)) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port(), "--sql-mode=ANSI_QUOTES") self.server2 = self.servers.spawn_server("compare_db_srv2_aq_mix", mysqld, True) if self.server2.select_variable("SQL_MODE") != "ANSI_QUOTES": raise MUTLibError("Failed to set SQL_MODE!=ANSI_QUOTES to server" " {0}:{1}".format(self.server2.host, self.server2.port)) self.drop_all() return True
def do_test(self, test_num, comment, command): """Do test. test_num[in] Test number. comment[in] Comment. command[in] Command. """ res = self.run_test_case(0, command, _BASE_COMMENT.format(test_num, comment)) if not res: raise MUTLibError("{0}: failed".format(comment))
def _load_data(self, server, data_file): """Reads and executes SQL from data file. server[in] Server instance. data_file[in] File name containing SQL statements. """ try: server.read_and_exec_SQL(data_file, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: " "{1}".format(data_file, err.errmsg))
def check_prerequisites(self): """ Check prerequisites to execute test. Return True if all prerequisites are met, otherwise a MUTLibError is issued. """ # Check required server version. # Reason: GTID requires servers > 5.6.9. if not self.servers.get_server(0).check_version_compat(5, 6, 9): raise MUTLibError("Test requires server version >= 5.6.9") return self.check_num_servers(1)
def check_prerequisites(self): # Need non-Windows platform if os.name == "nt": raise MUTLibError("Test requires a non-Windows platform.") # Need at least one server. self.server1 = self.servers.get_server(0) self.server2 = None self.need_server = False if not self.check_num_servers(2): self.need_server = True res = self.check_num_servers(1) rows = [] try: rows = self.server1.exec_query("SHOW DATABASES LIKE 'employees'") except: pass if len(rows) == 0: raise MUTLibError("Need employees database loaded on " "{0}".format(self.server1.role)) return res
def setup(self): res = check_rpl.test.setup(self) index = self.servers.find_server_by_name("rep_slave_ignore") if index >= 0: self.server3 = self.servers.get_server(index) try: res = self.server3.show_server_variable("server_id") except MUTLibError, e: raise MUTLibError("Cannot get replication slave " + "server_id: %s" % e.errmsg) self.s3_serverid = int(res[0][1])
def check_prerequisites(self): if self.servers.get_server(0).supports_gtid() != "ON" or \ not self.servers.get_server(0).check_version_compat(5,6,9): raise MUTLibError("Test requires server version 5.6.9 with " "GTID_MODE=ON.") if os.name == "nt": raise MUTLibError("Test does not run correctly on Windows. " "See BUG#16005010.") if os.name == "posix": self.failover_dir = "./fail_event" else: self.failover_dir = ".\\fail_event" if self.debug: print for log in ["1", "2", "3", "4"]: try: os.unlink(log + _FAILOVER_LOG) except: pass return rpl_admin_gtid.test.check_prerequisites(self)
def check_prerequisites(self): self.check_gtid_unsafe() if self.servers.get_server(0).check_version_compat(5, 6, 2): raise MUTLibError("Test requires server version prior to 5.6.2") # Need at least one server. self.server1 = None self.server2 = None self.gen_log = None self.slow_log = None self.error_log = None return self.check_num_servers(1)
def get_table_rows(self, comment): """Get list of rows from the slave. comment[in] Comment. """ try: res = self.server1.exec_query("SELECT * FROM log_test.t1") self.results.append(res) except UtilError as err: raise MUTLibError("{0}: Query failed. {1}".format( comment, err.errmsg))
def setup(self): self.server1 = self.servers.get_server(0) if self.need_server: try: self.servers.spawn_new_servers(2) except MUTLibError as err: raise MUTLibError("Cannot spawn needed servers: {0}".format( err.errmsg)) self.server2 = self.servers.get_server(1) self.drop_all() return True
def setup(self): self.server0 = self.servers.get_server(0) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server1 = self.servers.spawn_server("compare_db_srv1_ansi_quotes", mysqld, True) mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port()) self.server2 = self.servers.spawn_server("compare_db_srv2_ansi_quotes", mysqld, True) if self.server1.select_variable("SQL_MODE") != "ANSI_QUOTES": raise MUTLibError("Failed to set SQL_MODE=ANSI_QUOTES to server" " {0}:{1}".format(self.server1.host, self.server1.port)) if self.server2.select_variable("SQL_MODE") != "ANSI_QUOTES": raise MUTLibError("Failed to set SQL_MODE=ANSI_QUOTES to server" " {0}:{1}".format(self.server2.host, self.server2.port)) self.drop_all() return True
def setup(self): res = import_basic.test.setup(self) if not res: return False data_file = os.path.normpath("./std_data/basic_data.sql") try: res = self.server2.read_and_exec_SQL(data_file, self.debug) except MUTLibError, e: raise MUTLibError("Failed to read commands from file %s: " % \ data_file + e.errmsg)
def run(self): self.mask_global = False # Turn off global masks self.res_fname = "result.txt" from_conn = self.build_connection_string(self.server1) conn_val = self.get_connection_values(self.server1) cmd = ("mysqlprocgrep.py --server={0} " "--match-user={1} ".format(from_conn, conn_val[0])) test_case_num = 1 _FORMATS = ("CSV", "TAB", "VERTICAL", "GRID") for format_ in _FORMATS: comment = ("Test case {0} - find processes for current " "user format={1}".format(test_case_num, format_)) test_case_num += 1 cmd = "{0} --format={1} ".format(cmd, format_) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.results.append("\n") # CSV masks self.mask_column_result("root:*@localhost", ",", 1, "root[...]") self.mask_column_result("root[...]", ",", 2, "XXXXX") self.mask_column_result("root[...]", ",", 4, "localhost") self.mask_column_result("root[...]", ",", 7, "XXXXX") # TAB masks self.mask_column_result("root:*@localhost", "\t", 1, "root[...]") self.mask_column_result("root[...]", "\t", 2, "XXXXX") self.mask_column_result("root[...]", "\t", 4, "localhost") self.mask_column_result("root[...]", "\t", 7, "XXXXX") # Vertical masks self.replace_result(" Connection: ", " Connection: XXXXX\n") self.replace_result(" Id: ", " Id: XXXXX\n") self.replace_result(" Host: ", " Host: localhost\n") self.replace_result(" Time: ", " Time: XXXXX\n") # Grid masks # Here, we truncate all horizontal bars for deterministic results self.replace_result("+---", "+---+\n") self.mask_column_result("| root", "|", 2, " root[...] ") self.mask_column_result("| root[...] ", "|", 3, " XXXXX ") self.mask_column_result("| root[...] ", "|", 5, " localhost ") self.mask_column_result("| root[...] ", "|", 8, " XXXXX ") self.replace_result( "| Connection", "| Connection | Id | User | Host " "| Db | Command | Time | State " "| Info [...] |\n") return True
def exec_export_import(self, server1, server2, exp_cmd, imp_cmd, test_num, test_case, ret_val=True, reset=True, load_data=True): conn1 = "--server=" + self.build_connection_string(server1) conn2 = "--server=" + self.build_connection_string(server2) if load_data: try: res = server1.read_and_exec_SQL(self.data_file, self.debug) except UtilError, e: raise MUTLibError("Failed to read commands from file %s: %s" % (self.data_file, e.errmsg))
def setup(self): # Check available cloned servers and spawn one if needed. if self.servers.num_servers() < 2: try: self.servers.spawn_new_servers(2) except MUTLibError as err: raise MUTLibError("Cannot spawn needed servers: " "{0}".format(err.errmsg)) # Get first cloned server (only one needed). self.server1 = self.servers.get_server(1) # Load users data for test. data_file = "./std_data/basic_users.sql" try: self.server1.read_and_exec_SQL(data_file, self.debug) except (MUTLibError, UtilError) as err: raise MUTLibError( "Failed to read commands from file {0}: {1}".format( data_file, err.errmsg)) return True
def setup(self, spawn_servers=True): if spawn_servers: self.server1 = self.servers.get_server(0) if self.need_server: try: self.servers.spawn_new_servers(2) except MUTLibError as err: raise MUTLibError("Cannot spawn needed servers: {0}" "".format(err.errmsg)) if self.server2 is None: self.server2 = self.servers.get_server(1) self.drop_all() data_file = os.path.normpath("./std_data/basic_data.sql") try: self.server1.read_and_exec_SQL(data_file, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: {1}" "".format(data_file, err.errmsg)) # Create backtick database (with weird names) data_file_backticks = os.path.normpath("./std_data/backtick_data.sql") try: self.server1.read_and_exec_SQL(data_file_backticks, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: {1}" "".format(data_file_backticks, err.errmsg)) # Create database with test VIEWS. data_file_views = os.path.normpath("./std_data/db_copy_views.sql") try: self.server1.read_and_exec_SQL(data_file_views, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file " "{0}: {1}".format(data_file_views, err.errmsg)) # Load database with with blobs and insert data. data_file_blobs = os.path.normpath("./std_data/blob_data.sql") try: self.server1.read_and_exec_SQL(data_file_blobs, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: {1}" "".format(data_file_blobs, err.errmsg)) # Create user 'joe'@'localhost' in source server try: self.server1.exec_query("CREATE USER 'joe'@'localhost'") except UtilError as err: raise MUTLibError("Failed to create user: {0}".format(err.errmsg)) # Create user 'joe'@'localhost' in destination server try: self.server2.exec_query("CREATE USER 'joe'@'localhost'") except UtilError as err: raise MUTLibError("Failed to create user: {0}".format(err.errmsg)) return True
def setup(self): self.server0 = self.servers.get_server(0) self.frm_output = "frm_output.txt" self.s1_serverid = None index = self.servers.find_server_by_name("frm_test") if index >= 0: self.server1 = self.servers.get_server(index) try: res = self.server1.show_server_variable("server_id") except MUTLibError as err: raise MUTLibError("Cannot get frm test server " "server_id: {0}".format(err.errmsg)) self.s1_serverid = int(res[0][1]) else: self.s1_serverid = self.servers.get_next_id() res = self.servers.spawn_new_server( self.server0, self.s1_serverid, "frm_test", ' --mysqld="--log-bin=mysql-bin "') if not res: raise MUTLibError("Cannot spawn frm_test server.") self.server1 = res[0] self.servers.add_new_server(self.server1, True) self.drop_all() self.server1.exec_query("CREATE DATABASE frm_test") # Load a known CREATE TABLE|VIEW statement from file data_file = os.path.normpath("./std_data/frm_test.sql") try: with open(data_file, 'r') as f: queries = " ".join([a.strip("\n") for a in f]) sql_statements = queries.split(";") for table_sql in sql_statements: self.server1.exec_query(table_sql) except MUTLibError as err: raise MUTLibError("Failed to read commands from file " "{0}: {1}".format(data_file, err.errmsg)) return True
def exec_copy(self, server1, server2, copy_cmd, test_num, test_case, reset=True, load_data=True, ret_val=True): """Execute copy. server1[in] Server instance. server2[in] Server instance. copy_cmd[in] Copy command. test_num[in] Test number. test_case[in] Test case. reset[in] True for reset. load_data[in] True for load data. ret_val[in] Return value. """ conn1 = " --source={0}".format(self.build_connection_string(server1)) conn2 = " --destination={0}".format( self.build_connection_string(server2)) if load_data: try: server1.read_and_exec_SQL(self.data_file, self.debug) except UtilError as err: raise MUTLibError("Failed to read commands from file {0}: " "{1}".format(self.data_file, err.errmsg)) comment = "Test case {0} {1}".format(test_num, test_case) cmd_str = copy_cmd + conn1 + conn2 if reset: server2.exec_query("RESET MASTER") # reset GTID_EXECUTED res = mutlib.System_test.run_test_case(self, 0, cmd_str, comment) if not res == ret_val: for row in self.results: print row, raise MUTLibError("{0}: failed".format(comment)) self.drop_all()
def run(self): self.res_fname = "result.txt" from_conn = self.build_connection_string(self.server1) cmd_base = "mysqlmetagrep.py --server={0}".format(from_conn) test_num = 1 comment = "Test case {0} - invalid --character-set".format(test_num) cmd = ("{0} --pattern=%t1% --character-set=unsupported_charset" "".format(cmd_base)) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) test_num += 1 comment = "Test case {0} - invalid --object-type.".format(test_num) cmd = ("{0} --body --pattern=%t1% --object-types=function" "".format(cmd_base)) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) test_num += 1 comment = "Test case {0} - invalid --search-objects.".format(test_num) cmd = ("{0} --pattern=%t1% --object-types=routine,foo" "".format(cmd_base)) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) test_num += 1 comment = "Test case {0} - invalid user.".format(test_num) cmd_base = "mysqlmetagrep.py --server=nope@nada" cmd = ("{0} --pattern=%t1% --object-types=routine" "".format(cmd_base)) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.replace_result("ERROR: 2003: Can't connect to MySQL server", "ERROR: 2003: Can't connect to XXXX\n") return True
def run(self): self.res_fname = "result.txt" master_str = "--master=%s" % self.build_connection_string(self.server2) slave_str = " --slave=%s" % self.build_connection_string(self.server1) conn_str = master_str + slave_str cmd = "mysqlreplicate.py --rpl-user=rpl:rpl %s" % conn_str try: res = self.exec_util(cmd, self.res_fname) except MUTLibError, e: raise MUTLibError(e.errmsg)
def stop_slave(comment, slave): """Stop and flush the slave to disconnect are reset. comment[in] Comment. slave[in] Slave instance. """ try: slave.exec_query("STOP SLAVE") slave.exec_query("RESET SLAVE") except UtilError: raise MUTLibError( "{0}: Cannot stop and reset slave.".format(comment))