def setup(self): next_port = self.servers.view_next_port() self.mask_ports.append(next_port) mysqld = ("--log-bin=mysql-bin --report-port={0}").format(next_port) self.server2 = self.servers.spawn_server( "server2_binlog_purge", mysqld, True) next_port = self.servers.view_next_port() self.mask_ports.append(next_port) mysqld = ("--report-port={0}").format(next_port) self.server3 = self.servers.spawn_server( "server3_binlog_purge", mysqld, True) # Get datadir 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] # Create user without No privileges. if self.debug: print("\nCreating user without any privileges on server...") change_user_privileges(self.server2, 'an_user', 'a_pwd', self.server2.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) return True
def setup(self): next_port = self.servers.view_next_port() self.mask_ports.append(next_port) mysqld = ("--log-bin=mysql-bin --report-port={0}").format(next_port) self.server2 = self.servers.spawn_server( "server2_binlog_purge", mysqld, True) next_port = self.servers.view_next_port() self.mask_ports.append(next_port) mysqld = ("--report-port={0}").format(next_port) self.server3 = self.servers.spawn_server( "server3_binlog_purge", mysqld, True) # Get datadir 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] # Create user without No privileges. if self.debug: print("\nCreating user without any privileges on server...") change_user_privileges(self.server2, 'an_user', 'a_pwd', self.server2.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) return True
def setup(self): self.temp_files = [] self.test_results = [] self.test_cases = [] self.res_fname = "result.txt" res = failover.test.setup(self) if not res: return False # Range used for log filename (one for each test). self.log_range = range(1, 17) # Create user for master with minimum required privileges. master_grants = ['DROP', 'CREATE', 'INSERT', 'SELECT', 'REPLICATION SLAVE', 'SUPER', 'GRANT OPTION', 'RELOAD'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=True) # Create replication user and grant REPLICATION SLAVE privilege. grants = ['REPLICATION SLAVE'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=True) # Configure the replication topology for the new user. self.reset_topology(rpl_user='******', rpl_passwd='s_pwd') return True
def setup(self): self.temp_files = [] self.test_results = [] self.test_cases = [] self.res_fname = "result.txt" res = failover.test.setup(self) if not res: return False # Range used for log filename (one for each test). self.log_range = range(1, 17) # Create user for master with minimum required privileges. master_grants = [ 'DROP', 'CREATE', 'INSERT', 'SELECT', 'REPLICATION SLAVE', 'SUPER', 'GRANT OPTION', 'RELOAD' ] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=True) # Create replication user and grant REPLICATION SLAVE privilege. grants = ['REPLICATION SLAVE'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=True) # Configure the replication topology for the new user. self.reset_topology(rpl_user='******', rpl_passwd='s_pwd') return True
def run(self): self.mask_global = False # Turn off global masks # Create connection strings. master_conn = self.build_custom_connection_string(self.server1, 'm_user', 'm_pwd') slave1_conn = self.build_custom_connection_string(self.server2, 's_user', 's_pwd') slave2_conn = self.build_custom_connection_string(self.server3, 's_user', 's_pwd') slave3_conn = self.build_custom_connection_string(self.server4, 's_user', 's_pwd') # Use 'repl' user for all slaves. slaves_str = ",".join([slave1_conn, slave2_conn, slave3_conn]) base_cmd = ( '{0}mysqlfailover.py --interval=10 --timeout=5 ' '--master={1} --slaves={2} --discover-slaves-login=s_user:s_pwd ' '--failover-mode={3} --exec-post-failover="{4}" --log={5}' ) # Test failover using slave users with missing privileges. # Only: REPLICATION SLAVE. # This privilege is mandatory for slaves to connect to the master. test_num = 1 comment = ("Test case {0} - failover (fail) using 's_user' only with: " "REPLICATION SLAVE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SUPER to user on slaves. grants = ['GRANT OPTION', 'SELECT', 'RELOAD', 'DROP', 'CREATE', 'INSERT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "SUPER.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except DROP to user on slaves. grants = ['SUPER'] revokes = ['DROP'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: DROP. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "DROP.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except CREATE to user on slaves. grants = ['DROP'] revokes = ['CREATE'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: CREATE. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "CREATE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except GRANT OPTION to user on slaves. grants = ['CREATE'] revokes = ['GRANT OPTION'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: GRANT OPTION. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "GRANT OPTION.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on slaves. grants = ['GRANT OPTION'] revokes = ['SELECT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "SELECT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except RELOAD to user on slaves. grants = ['SELECT'] revokes = ['RELOAD'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: RELOAD. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "RELOAD.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except INSERT to user on slaves. grants = ['RELOAD'] revokes = ['INSERT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: INSERT. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on slaves. grants = ['INSERT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Grant all required privileges except REPLICATION SLAVE to user on # master. revokes = ['REPLICATION SLAVE'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=None, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using a master user with missing privilege: REPLICATION # SLAVE. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "REPLICATION SLAVE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SUPER to user on master. grants = ['REPLICATION SLAVE'] revokes = ['SUPER'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using a master user with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "SUPER.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except DROP to user on master. grants = ['SUPER'] revokes = ['DROP'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: DROP. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "DROP.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except CREATE to user on master. grants = ['DROP'] revokes = ['CREATE'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: CREATE. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "CREATE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except GRANT OPTION to user on master. grants = ['CREATE'] revokes = ['GRANT OPTION'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: GRANT OPTION. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "GRANT OPTION.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on master. grants = ['GRANT OPTION'] revokes = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "SELECT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except RELOAD to user on master. grants = ['SELECT'] revokes = ['RELOAD'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: RELOAD. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "RELOAD.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except INSERT to user on master. grants = ['RELOAD'] revokes = ['INSERT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: INSERT. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. grants = ['INSERT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Apply masks. self.do_masks() self.replace_substring(" (42000)", "") # Test failover using users (for master and slaves) with all required # privileges: REPLICATION SLAVE, SUPER, GRANT OPTION, SELECT, RELOAD, # DROP, CREATE, and INSERT. test_num += 1 comment = ("Test case {0} - failover (succeed) using 's_user' and " "'m_user' with: REPLICATION SLAVE, SUPER, GRANT OPTION, " "SELECT, RELOAD, DROP, CREATE, INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) key_phrase = "Failover complete" cmd = base_cmd.format('python ../scripts/', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) test_case = (self.server1, cmd, True, log_file, comment, key_phrase, False) res = self.test_failover_console(test_case) if res: self.test_results.append(res) # Append test result to result file. self.results.append("{0}\n".format(res[0])) self.results.append("{0} ? {1}\n".format(key_phrase, res[1])) else: raise MUTLibError("{0}: failed".format(test_case[4])) self.remove_result("NOTE: Log file") return True
def run(self): # Create user to test privileges on master and slave. # Missing privilege on the master (SUPER and REPLICATION CLIENT). if self.debug: print("\nCreate user with missing privileges (SUPER and " "REPLICATION CLIENT) on master.") master_grants = ['LOCK TABLES', 'SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=True) if self.debug: print("\nCreate user with all required privileges on slave.") slave_grants = ['SUPER', 'SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server1.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=True) master_con = self.build_custom_connection_string( self.server1, 'm_user', 'm_pwd') slave1_con = self.build_custom_connection_string( self.server2, 's_user', 's_pwd') cmd_base = "mysqlrplsync.py --master={0} --slaves={1}".format( master_con, slave1_con) if self.debug: print("\nCreate test database and tables on master.") rpl_sync.create_test_db(self.server1) if self.debug: print("\nWait for slaves to catch up with master.") self.wait_for_slaves([self.server2]) # Test sync using a master user with missing privilege: SUPER and # REPLICATION CLIENT. test_num = 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "SUPER and REPLICATION CLIENT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except LOCK TABLES to user on master. if self.debug: print("\nGrant required privileges except LOCK TABLES on master.") master_grants = ['SUPER'] master_revokes = ['LOCK TABLES'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync using a master user with missing privilege: LOCK TABLES. test_num += 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "LOCK TABLES.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on master. if self.debug: print("\nGrant required privileges except SELECT on master.") master_grants = ['LOCK TABLES'] master_revokes = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync using a master user with missing privilege: LOCK TABLES. test_num += 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "SELECT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. if self.debug: print("\nGrant required privileges on master.") master_grants = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=False) # Grant all required privileges except SUPER to user on slave. if self.debug: print("\nGrant required privileges except SUPER on slave.") slave_revokes = ['SUPER'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=None, revoke_list=slave_revokes, disable_binlog=True, create_user=False) # Test sync using a slave user with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - sync (fail) using 's_user' without: " "SUPER.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on slave. if self.debug: print("\nGrant required privileges except SELECT on slave.") slave_grants = ['SUPER'] slave_revokes = ['SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=slave_revokes, disable_binlog=True, create_user=False) # Test sync using a slave user with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - sync (fail) using 's_user' without: " "SELECT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on slave. if self.debug: print("\nGrant required privileges on slave.") slave_grants = ['SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) # Test sync with master and slave users with all required privileges. # Using SUPER (not REPLICATION CLIENT) for master. test_num += 1 comment = ("Test case {0} - sync (succeed) using: 'm_user' with " "SUPER, LOCK TABLES and SELECT; 's_user' with SUPER and " "SELECT.".format(test_num)) res = self.run_test_case(0, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Replace SUPER with REPLICATION CLIENT for user on master. if self.debug: print("\nReplace SUPER with REPLICATION CLIENT on master.") master_grants = ['REPLICATION CLIENT'] master_revokes = ['SUPER'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync with master and slave users with all required privileges. # Using REPLICATION CLIENT (not SUPER) for master. test_num += 1 comment = ("Test case {0} - sync (succeed) using: 'm_user' with " "REPLICATION CLIENT, LOCK TABLES and SELECT; 's_user' with " "SUPER and SELECT.".format(test_num)) res = self.run_test_case(0, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Mask out non-deterministic data self.do_masks() return True
def run(self): self.mask_global = False # Turn off global masks # Create connection strings. master_conn = self.build_custom_connection_string( self.server1, 'm_user', 'm_pwd') slave1_conn = self.build_custom_connection_string( self.server2, 's_user', 's_pwd') slave2_conn = self.build_custom_connection_string( self.server3, 's_user', 's_pwd') slave3_conn = self.build_custom_connection_string( self.server4, 's_user', 's_pwd') # Use 'repl' user for all slaves. slaves_str = ",".join([slave1_conn, slave2_conn, slave3_conn]) base_cmd = ( '{0}mysqlfailover.py --interval=10 --timeout=5 ' '--master={1} --slaves={2} --discover-slaves-login=s_user:s_pwd ' '--failover-mode={3} --exec-post-failover="{4}" --log={5}') # Test failover using slave users with missing privileges. # Only: REPLICATION SLAVE. # This privilege is mandatory for slaves to connect to the master. test_num = 1 comment = ("Test case {0} - failover (fail) using 's_user' only with: " "REPLICATION SLAVE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SUPER to user on slaves. grants = [ 'GRANT OPTION', 'SELECT', 'RELOAD', 'DROP', 'CREATE', 'INSERT' ] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "SUPER.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except DROP to user on slaves. grants = ['SUPER'] revokes = ['DROP'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: DROP. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "DROP.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except CREATE to user on slaves. grants = ['DROP'] revokes = ['CREATE'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: CREATE. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "CREATE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except GRANT OPTION to user on slaves. grants = ['CREATE'] revokes = ['GRANT OPTION'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: GRANT OPTION. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "GRANT OPTION.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on slaves. grants = ['GRANT OPTION'] revokes = ['SELECT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "SELECT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except RELOAD to user on slaves. grants = ['SELECT'] revokes = ['RELOAD'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: RELOAD. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "RELOAD.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except INSERT to user on slaves. grants = ['RELOAD'] revokes = ['INSERT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using slave users with missing privilege: INSERT. test_num += 1 comment = ("Test case {0} - failover (fail) using 's_user' without: " "INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on slaves. grants = ['INSERT'] for slave in [self.server2, self.server3, self.server4]: change_user_privileges(slave, 's_user', 's_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Grant all required privileges except REPLICATION SLAVE to user on # master. revokes = ['REPLICATION SLAVE'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=None, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using a master user with missing privilege: REPLICATION # SLAVE. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "REPLICATION SLAVE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SUPER to user on master. grants = ['REPLICATION SLAVE'] revokes = ['SUPER'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using a master user with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "SUPER.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except DROP to user on master. grants = ['SUPER'] revokes = ['DROP'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: DROP. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "DROP.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except CREATE to user on master. grants = ['DROP'] revokes = ['CREATE'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: CREATE. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "CREATE.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except GRANT OPTION to user on master. grants = ['CREATE'] revokes = ['GRANT OPTION'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: GRANT OPTION. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "GRANT OPTION.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on master. grants = ['GRANT OPTION'] revokes = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "SELECT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except RELOAD to user on master. grants = ['SELECT'] revokes = ['RELOAD'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: RELOAD. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "RELOAD.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except INSERT to user on master. grants = ['RELOAD'] revokes = ['INSERT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Test failover using master user with missing privilege: INSERT. test_num += 1 comment = ("Test case {0} - failover (fail) using 'm_user' without: " "INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) cmd = base_cmd.format('', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. grants = ['INSERT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Apply masks. self.do_masks() self.replace_substring(" (42000)", "") # Test failover using users (for master and slaves) with all required # privileges: REPLICATION SLAVE, SUPER, GRANT OPTION, SELECT, RELOAD, # DROP, CREATE, and INSERT. test_num += 1 comment = ("Test case {0} - failover (succeed) using 's_user' and " "'m_user' with: REPLICATION SLAVE, SUPER, GRANT OPTION, " "SELECT, RELOAD, DROP, CREATE, INSERT.".format(test_num)) log_file = failover.FAILOVER_LOG.format(test_num) key_phrase = "Failover complete" cmd = base_cmd.format('python ../scripts/', master_conn, slaves_str, 'auto', self.fail_event_script, log_file) test_case = (self.server1, cmd, True, log_file, comment, key_phrase, False) res = self.test_failover_console(test_case) if res: self.test_results.append(res) # Append test result to result file. self.results.append("{0}\n".format(res[0])) self.results.append("{0} ? {1}\n".format(key_phrase, res[1])) else: raise MUTLibError("{0}: failed".format(test_case[4])) self.remove_result("NOTE: Log file") return True
def run_set(self, option_name, test_num, cmd_str, server, datadir, ad_opt=""): """Runs a set of test for the given option. option_name[in] Option to use along the server connection string test_num[in] Test cane number cmd_str[in] Utility module name to run server[in] Server instance used to run the test datadir[in] the datadir path to check ad_opt[in] Additional command option Returns latest test case number used. """ server_con = self.build_custom_connection_string( server, 'a_user', 'a_pwd') # Create user without any privileges. if self.debug: print("\nCreating user without any privileges on server...") change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) # Purge binary logs using a user with no privileges. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "privileges, {1} option (fail).".format( test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except REPLICATION SLAVE). if self.debug: print("\nGrant all required privileges except REPLICATION SLAVE.") grants = ['SUPER'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Purge binary logs using a user without REPLICATION SLAVE. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "REPLICATION SLAVE, {1} option (fail).".format( test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except SUPER). if self.debug: print("\nGrant all required privileges except SUPER.") revokes = ['SUPER'] grants = ['REPLICATION SLAVE'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Purge binary logs using a user without REPLICATION SLAVE. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "SUPER, {1} option (fail).".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except SUPER). if self.debug: print("\nGrant all required privileges (REPLICATION SLAVE and " "SUPER).") grants = ['SUPER'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Purge binary logs using a user with all required privileges # (REPLICATION SLAVE and SUPER). test_num += 1 comment = ("Test case {0} - Purge binlog using a user with required " "privileges (REPLICATION SLAVE and SUPER)" ", {1} option.".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(0, cmd, comment) if not res or binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Mask results self.replace_substring("localhost", "XXXX-XXXX") p_n = 0 for port in self.mask_ports: p_n += 1 self.replace_substring(repr(port), "PORT{0}".format(p_n)) return test_num
def run(self): """ Run the test cases. Return True if all tests pass, otherwise a MUTLibError is issued. """ cmd_base = "mysqlslavetrx.py" # Create user to test privileges on slaves. # No privileges granted to user on slave. if self.debug: print("\nCreating user without any privileges on slaves...") for srv in [self.server2, self.server3]: change_user_privileges(srv, 's_user', 's_pwd', srv.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) slave1_con = self.build_custom_connection_string(self.server2, 's_user', 's_pwd') slave2_con = self.build_custom_connection_string(self.server3, 's_user', 's_pwd') slaves_con = ",".join([slave1_con, slave2_con]) if self.debug: print("\nGet UUID of each server:") uuids = [] for srv in [self.server1, self.server2, self.server3]: uuids.append(srv.get_server_uuid()) if self.debug: for uuid in uuids: print("- {0}".format(uuid)) # Wait for slaves to catch up to ensure that the GTID_EXECUTED is the # same on all servers. if self.debug: print("\nWait for slaves to catch up with master.") self.wait_for_slaves() test_num = 1 comment = ("Test case {0} - Skip GTIDs (fail) using 's_user': no " "privileges on all slaves.").format(test_num) gtid_set = "{0}:7,{1}:7,{2}:7".format(*uuids) cmd = "{0} --slaves={1} --gtid-set={2}".format(cmd_base, slaves_con, gtid_set) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges (SUPER) to user on Slave 1. if self.debug: print("\nGrant all required privileges (SUPER) on Slave 1.") slave_grants = ['SUPER'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) test_num += 1 comment = ("Test case {0} - Skip GTIDs (fail) using 's_user': "******"SUPER for slave1 and no privileges for slave2." "").format(test_num) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges (SUPER) to user on Slave 2. if self.debug: print("\nGrant all required privileges (SUPER) on Slave 2.") change_user_privileges(self.server3, 's_user', 's_pwd', self.server3.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) test_num += 1 comment = ("Test case {0} - Skip GTIDs (succeed) using 's_user': "******"SUPER for all slaves." "").format(test_num) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Computed expected GTID_EXECUTED set for all slaves. master_gtid_executed = self.server1.get_gtid_executed() expected_gtids = gtid_set_union(master_gtid_executed, gtid_set) if self.debug: print("\nExpected GTID_EXECUTED set: {0}".format(expected_gtids)) # Check if GTID_EXECUTED match the expected value on all slaves. try: slave_trx_skip.check_gtid_executed([self.server2, self.server3], expected_gtids) except UtilError as err: raise MUTLibError("{0}: failed\n{1}".format(comment, err.errmsg)) # Mask non-deterministic output. self.replace_substring(str(self.server1.port), "PORT1") self.replace_substring(str(self.server2.port), "PORT2") self.replace_substring(str(self.server3.port), "PORT3") # Mask UUID values in GTIDs. self.replace_substring(uuids[0], "UUID_m") self.replace_substring(uuids[1], "UUID_s1") self.replace_substring(uuids[2], "UUID_s2") return True
def run(self): cmd_base = "mysqlbinlogmove.py" # Create user to test privileges on master and slave. # No privileges granted to user on master. if self.debug: print("\nCreating user without any privileges on master...") change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) # No privileges granted to user on slave. if self.debug: print("\nCreating user without any privileges on slave...") change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) master_con = self.build_custom_connection_string(self.server1, 'm_user', 'm_pwd') slave1_con = self.build_custom_connection_string(self.server2, 's_user', 's_pwd') # Disable automatic relay log purging on slave. self.server2.exec_query('SET GLOBAL relay_log_purge = 0') # Generate multiple binary log files. if self.debug: print("\nCreate multiple binary logs on all servers " "(FLUSH LOCAL LOGS)...") for srv in [self.server1, self.server2]: for _ in range(5): srv.exec_query('FLUSH LOCAL LOGS') # Stop slave to avoid the creation of more relay logs. self.server2.exec_query('STOP SLAVE') master_src = self.server1.select_variable('datadir') if self.debug: print("\nServer {0}:{1} source directory (datadir): " "{2}".format(self.server1.host, self.server1.port, master_src)) # Move all binary log files on master, using a user with no privileges. test_num = 1 comment = ("Test case {0}a - move binary logs (fail) using: " "'m_user' with no privileges.").format(test_num) cmd = "{0} --server={1} --log-type=all {2}".format(cmd_base, master_con, self.master_dir) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. if self.debug: print("\nGrant all required privileges on master.") master_grants = ['RELOAD'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=False) # Move all binary log files on master, using a user with all required # privileges (RELOAD). test_num += 1 comment = ("Test case {0}a - move binary logs (succeed) using: " "'m_user' with RELOAD privilege.").format(test_num) cmd = "{0} --server={1} --log-type=all {2}".format(cmd_base, master_con, self.master_dir) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.results.append("Test case {0}b - check moved files and changes " "in index file:\n".format(test_num)) self.check_moved_binlogs(self.master_dir, master_src, 'master-bin.index') slave1_src = self.server2.select_variable('datadir') if self.debug: print("\nServer {0}:{1} source directory (datadir): " "{2}".format(self.server2.host, self.server2.port, slave1_src)) # Wait for all relay log files to be created on the slave. self.wait_for_file(slave1_src, 'slave1-relay-bin.000018') # Move all binary log files on slave with --skip-flush-binlogs, using # a user with no privileges. test_num += 1 comment = ("Test case {0}a - move binary logs (succeed) with " "--skip-flush-binlogs using: 's_user' with no privileges" ".").format(test_num) cmd = ("{0} --server={1} --log-type=all --skip-flush-binlogs " "{2}").format(cmd_base, slave1_con, self.slave1_dir) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.results.append("Test case {0}b - check moved files and changes " "in index file:\n".format(test_num)) self.check_moved_binlogs(self.slave1_dir, slave1_src, 'slave1-bin.index', 'slave1-relay-bin', 'slave1-relay-bin.index') # Mask non-deterministic data. self.replace_substring(str(self.server1.port), "PORT1") # Warning messages for older MySQL versions (variables not available). self.remove_result("# WARNING: Variable 'relay_log_basename' is not " "available for server ") self.remove_result("# WARNING: Variable 'log_bin_basename' is not " "available for server ") return True
def run_set(self, option_name, test_num, cmd_str, server, datadir, ad_opt=""): """Runs a set of test for the given option. option_name[in] Option to use along the server connection string test_num[in] Test cane number cmd_str[in] Utility module name to run server[in] Server instance used to run the test datadir[in] the datadir path to check ad_opt[in] Additional command option Returns latest test case number used. """ server_con = self.build_custom_connection_string(server, 'a_user', 'a_pwd') # Create user without any privileges. if self.debug: print("\nCreating user without any privileges on server...") change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) # Purge binary logs using a user with no privileges. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "privileges, {1} option (fail).".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except REPLICATION SLAVE). if self.debug: print("\nGrant all required privileges except REPLICATION SLAVE.") grants = ['SUPER'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Purge binary logs using a user without REPLICATION SLAVE. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "REPLICATION SLAVE, {1} option (fail).".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except SUPER). if self.debug: print("\nGrant all required privileges except SUPER.") revokes = ['SUPER'] grants = ['REPLICATION SLAVE'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=revokes, disable_binlog=True, create_user=False) # Purge binary logs using a user without REPLICATION SLAVE. test_num += 1 comment = ("Test case {0} - Purge binlog using a user without " "SUPER, {1} option (fail).".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(1, cmd, comment) if not res or not binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Grant all required privilege to user (except SUPER). if self.debug: print("\nGrant all required privileges (REPLICATION SLAVE and " "SUPER).") grants = ['SUPER'] change_user_privileges(server, 'a_user', 'a_pwd', server.host, grant_list=grants, revoke_list=None, disable_binlog=True, create_user=False) # Purge binary logs using a user with all required privileges # (REPLICATION SLAVE and SUPER). test_num += 1 comment = ("Test case {0} - Purge binlog using a user with required " "privileges (REPLICATION SLAVE and SUPER)" ", {1} option.".format(test_num, option_name)) cmd = cmd_str.format("--{0}={1} {2}".format(option_name, server_con, ad_opt)) res = self.run_test_case(0, cmd, comment) if not res or binlog_file_exists(datadir, "mysql-bin.000001", self.debug): raise MUTLibError("{0}: failed".format(comment)) # Mask results self.replace_substring("localhost", "XXXX-XXXX") p_n = 0 for port in self.mask_ports: p_n += 1 self.replace_substring(repr(port), "PORT{0}".format(p_n)) return test_num
def run(self): """ Run the test cases. Return True if all tests pass, otherwise a MUTLibError is issued. """ cmd_base = "mysqlslavetrx.py" # Create user to test privileges on slaves. # No privileges granted to user on slave. if self.debug: print("\nCreating user without any privileges on slaves...") for srv in [self.server2, self.server3]: change_user_privileges(srv, 's_user', 's_pwd', srv.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) slave1_con = self.build_custom_connection_string( self.server2, 's_user', 's_pwd') slave2_con = self.build_custom_connection_string( self.server3, 's_user', 's_pwd') slaves_con = ",".join([slave1_con, slave2_con]) if self.debug: print("\nGet UUID of each server:") uuids = [] for srv in [self.server1, self.server2, self.server3]: uuids.append(srv.get_server_uuid()) if self.debug: for uuid in uuids: print("- {0}".format(uuid)) # Wait for slaves to catch up to ensure that the GTID_EXECUTED is the # same on all servers. if self.debug: print("\nWait for slaves to catch up with master.") self.wait_for_slaves() test_num = 1 comment = ("Test case {0} - Skip GTIDs (fail) using 's_user': no " "privileges on all slaves.").format(test_num) gtid_set = "{0}:7,{1}:7,{2}:7".format(*uuids) cmd = "{0} --slaves={1} --gtid-set={2}".format(cmd_base, slaves_con, gtid_set) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges (SUPER) to user on Slave 1. if self.debug: print("\nGrant all required privileges (SUPER) on Slave 1.") slave_grants = ['SUPER'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) test_num += 1 comment = ("Test case {0} - Skip GTIDs (fail) using 's_user': "******"SUPER for slave1 and no privileges for slave2." "").format(test_num) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges (SUPER) to user on Slave 2. if self.debug: print("\nGrant all required privileges (SUPER) on Slave 2.") change_user_privileges(self.server3, 's_user', 's_pwd', self.server3.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) test_num += 1 comment = ("Test case {0} - Skip GTIDs (succeed) using 's_user': "******"SUPER for all slaves." "").format(test_num) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Computed expected GTID_EXECUTED set for all slaves. master_gtid_executed = self.server1.get_gtid_executed() expected_gtids = gtid_set_union(master_gtid_executed, gtid_set) if self.debug: print("\nExpected GTID_EXECUTED set: {0}".format(expected_gtids)) # Check if GTID_EXECUTED match the expected value on all slaves. try: slave_trx_skip.check_gtid_executed([self.server2, self.server3], expected_gtids) except UtilError as err: raise MUTLibError("{0}: failed\n{1}".format(comment, err.errmsg)) # Mask non-deterministic output. self.replace_substring(str(self.server1.port), "PORT1") self.replace_substring(str(self.server2.port), "PORT2") self.replace_substring(str(self.server3.port), "PORT3") # Mask UUID values in GTIDs. self.replace_substring(uuids[0], "UUID_m") self.replace_substring(uuids[1], "UUID_s1") self.replace_substring(uuids[2], "UUID_s2") return True
def run(self): cmd_base = "mysqlbinlogmove.py" # Create user to test privileges on master and slave. # No privileges granted to user on master. if self.debug: print("\nCreating user without any privileges on master...") change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) # No privileges granted to user on slave. if self.debug: print("\nCreating user without any privileges on slave...") change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=None, revoke_list=None, disable_binlog=True, create_user=True) master_con = self.build_custom_connection_string( self.server1, 'm_user', 'm_pwd') slave1_con = self.build_custom_connection_string( self.server2, 's_user', 's_pwd') # Disable automatic relay log purging on slave. self.server2.exec_query('SET GLOBAL relay_log_purge = 0') # Generate multiple binary log files. if self.debug: print("\nCreate multiple binary logs on all servers " "(FLUSH LOCAL LOGS)...") for srv in [self.server1, self.server2]: for _ in range(5): srv.exec_query('FLUSH LOCAL LOGS') # Stop slave to avoid the creation of more relay logs. self.server2.exec_query('STOP SLAVE') master_src = self.server1.select_variable('datadir') if self.debug: print("\nServer {0}:{1} source directory (datadir): " "{2}".format(self.server1.host, self.server1.port, master_src)) # Move all binary log files on master, using a user with no privileges. test_num = 1 comment = ("Test case {0}a - move binary logs (fail) using: " "'m_user' with no privileges.").format(test_num) cmd = "{0} --server={1} --log-type=all {2}".format( cmd_base, master_con, self.master_dir) res = self.run_test_case(1, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. if self.debug: print("\nGrant all required privileges on master.") master_grants = ['RELOAD'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=False) # Move all binary log files on master, using a user with all required # privileges (RELOAD). test_num += 1 comment = ("Test case {0}a - move binary logs (succeed) using: " "'m_user' with RELOAD privilege.").format(test_num) cmd = "{0} --server={1} --log-type=all {2}".format( cmd_base, master_con, self.master_dir) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.results.append("Test case {0}b - check moved files and changes " "in index file:\n".format(test_num)) self.check_moved_binlogs(self.master_dir, master_src, 'master-bin.index') slave1_src = self.server2.select_variable('datadir') if self.debug: print("\nServer {0}:{1} source directory (datadir): " "{2}".format(self.server2.host, self.server2.port, slave1_src)) # Wait for all relay log files to be created on the slave. self.wait_for_file(slave1_src, 'slave1-relay-bin.000018') # Move all binary log files on slave with --skip-flush-binlogs, using # a user with no privileges. test_num += 1 comment = ("Test case {0}a - move binary logs (succeed) with " "--skip-flush-binlogs using: 's_user' with no privileges" ".").format(test_num) cmd = ("{0} --server={1} --log-type=all --skip-flush-binlogs " "{2}").format(cmd_base, slave1_con, self.slave1_dir) res = self.run_test_case(0, cmd, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) self.results.append("Test case {0}b - check moved files and changes " "in index file:\n".format(test_num)) self.check_moved_binlogs(self.slave1_dir, slave1_src, 'slave1-bin.index', 'slave1-relay-bin', 'slave1-relay-bin.index') # Mask non-deterministic data. self.replace_substring(str(self.server1.port), "PORT1") # Warning messages for older MySQL versions (variables not available). self.remove_result("# WARNING: Variable 'relay_log_basename' is not " "available for server ") self.remove_result("# WARNING: Variable 'log_bin_basename' is not " "available for server ") return True
def run(self): self.res_fname = "result.txt" cmd_str = "mysqlbinlogrotate.py " serv_conn = self.build_custom_connection_string(self.server2, 'a_user', 'a_pwd') test_num = 1 test_cases = ( {"comment": "with no privileges", "grant_list": None, "revoke_list": None, "exp_cmd_res": 1, "rotation_expected": False}, {"comment": "with RELOAD privilege only", "grant_list": ['RELOAD'], "revoke_list": None, "exp_cmd_res": 1, "rotation_expected": False}, {"comment": "with REPLICATION CLIENT privilege only", "grant_list": ['REPLICATION CLIENT'], "revoke_list": ['RELOAD'], "exp_cmd_res": 1, "rotation_expected": False}, {"comment": "with RELOAD and REPLICATION CLIENT privileges", "grant_list": ['RELOAD'], "revoke_list": None, "exp_cmd_res": 0, "rotation_expected": True} ) create_user = True for test_case in test_cases: # Create user if has not been created, also grant and revoke # privileges as required by the test case. if self.debug: print("\nChanging user privileges\n granting: {0}\n " "revoking: {1}".format(test_case["grant_list"], test_case["revoke_list"])) change_user_privileges(self.server2, 'a_user', 'a_pwd', self.server2.host, grant_list=test_case["grant_list"], revoke_list=test_case["revoke_list"], disable_binlog=True, create_user=create_user) create_user = False rot_exp = test_case["rotation_expected"] comment = ("Test case {0} - rotate on server {1} " "and -vv".format(test_num, test_case["comment"])) cmd = "{0} --server={1} -vv".format(cmd_str, serv_conn) res = self.run_test_case(test_case["exp_cmd_res"], cmd, comment) if not res or \ (rot_exp ^ binlog_file_exists(self.server2_datadir, "mysql-bin.000002", self.debug)): raise MUTLibError("{0}: failed".format(comment)) test_num += 1 self.replace_substring("localhost", "XXXX-XXXX") p_n = 0 for port in self.mask_ports: p_n += 1 self.replace_substring(repr(port), "PORT{0}".format(p_n)) self.replace_result( "# Active binlog file: ", "# Active binlog file: 'XXXXX-XXX:XXXXXX' (size: XXX bytes)\n" ) return True
def run(self): # Create user to test privileges on master and slave. # Missing privilege on the master (SUPER and REPLICATION CLIENT). if self.debug: print("\nCreate user with missing privileges (SUPER and " "REPLICATION CLIENT) on master.") master_grants = ['LOCK TABLES', 'SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=True) if self.debug: print("\nCreate user with all required privileges on slave.") slave_grants = ['SUPER', 'SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server1.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=True) master_con = self.build_custom_connection_string(self.server1, 'm_user', 'm_pwd') slave1_con = self.build_custom_connection_string(self.server2, 's_user', 's_pwd') cmd_base = "mysqlrplsync.py --master={0} --slaves={1}".format( master_con, slave1_con ) if self.debug: print("\nCreate test database and tables on master.") rpl_sync.create_test_db(self.server1) if self.debug: print("\nWait for slaves to catch up with master.") self.wait_for_slaves([self.server2]) # Test sync using a master user with missing privilege: SUPER and # REPLICATION CLIENT. test_num = 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "SUPER and REPLICATION CLIENT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except LOCK TABLES to user on master. if self.debug: print("\nGrant required privileges except LOCK TABLES on master.") master_grants = ['SUPER'] master_revokes = ['LOCK TABLES'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync using a master user with missing privilege: LOCK TABLES. test_num += 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "LOCK TABLES.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on master. if self.debug: print("\nGrant required privileges except SELECT on master.") master_grants = ['LOCK TABLES'] master_revokes = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync using a master user with missing privilege: LOCK TABLES. test_num += 1 comment = ("Test case {0} - sync (fail) using 'm_user' without: " "SELECT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on master. if self.debug: print("\nGrant required privileges on master.") master_grants = ['SELECT'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=None, disable_binlog=True, create_user=False) # Grant all required privileges except SUPER to user on slave. if self.debug: print("\nGrant required privileges except SUPER on slave.") slave_revokes = ['SUPER'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=None, revoke_list=slave_revokes, disable_binlog=True, create_user=False) # Test sync using a slave user with missing privilege: SUPER. test_num += 1 comment = ("Test case {0} - sync (fail) using 's_user' without: " "SUPER.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges except SELECT to user on slave. if self.debug: print("\nGrant required privileges except SELECT on slave.") slave_grants = ['SUPER'] slave_revokes = ['SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=slave_revokes, disable_binlog=True, create_user=False) # Test sync using a slave user with missing privilege: SELECT. test_num += 1 comment = ("Test case {0} - sync (fail) using 's_user' without: " "SELECT.".format(test_num)) res = self.run_test_case(1, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Grant all required privileges to user on slave. if self.debug: print("\nGrant required privileges on slave.") slave_grants = ['SELECT'] change_user_privileges(self.server2, 's_user', 's_pwd', self.server2.host, grant_list=slave_grants, revoke_list=None, disable_binlog=True, create_user=False) # Test sync with master and slave users with all required privileges. # Using SUPER (not REPLICATION CLIENT) for master. test_num += 1 comment = ("Test case {0} - sync (succeed) using: 'm_user' with " "SUPER, LOCK TABLES and SELECT; 's_user' with SUPER and " "SELECT.".format(test_num)) res = self.run_test_case(0, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Replace SUPER with REPLICATION CLIENT for user on master. if self.debug: print("\nReplace SUPER with REPLICATION CLIENT on master.") master_grants = ['REPLICATION CLIENT'] master_revokes = ['SUPER'] change_user_privileges(self.server1, 'm_user', 'm_pwd', self.server1.host, grant_list=master_grants, revoke_list=master_revokes, disable_binlog=True, create_user=False) # Test sync with master and slave users with all required privileges. # Using REPLICATION CLIENT (not SUPER) for master. test_num += 1 comment = ("Test case {0} - sync (succeed) using: 'm_user' with " "REPLICATION CLIENT, LOCK TABLES and SELECT; 's_user' with " "SUPER and SELECT.".format(test_num)) res = self.run_test_case(0, cmd_base, comment) if not res: raise MUTLibError("{0}: failed".format(comment)) # Mask out non-deterministic data self.do_masks() return True