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
