def test_start_stop(self):
"""Test start/stop slave functions.
"""
# Set up replication.
master = self.master
slave = self.slave
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
# Start SQL Thread.
start_slave(slave, wait=True, threads=(SQL_THREAD, ))
status = get_slave_status(slave)
self.assertEqual(status[0].Slave_IO_Running.upper(), "NO")
self.assertEqual(status[0].Slave_SQL_Running.upper(), "YES")
# Start IO Thread.
start_slave(slave, wait=True, threads=(IO_THREAD, ))
status = get_slave_status(slave)
self.assertEqual(status[0].Slave_IO_Running.upper(), "YES")
self.assertEqual(status[0].Slave_SQL_Running.upper(), "YES")
# Stop IO Thread
stop_slave(slave, wait=True, threads=(IO_THREAD, ))
status = get_slave_status(slave)
self.assertEqual(status[0].Slave_IO_Running.upper(), "NO")
self.assertEqual(status[0].Slave_SQL_Running.upper(), "YES")
# Stop IO Thread
stop_slave(slave, wait=True, threads=(SQL_THREAD, ))
status = get_slave_status(slave)
self.assertEqual(status[0].Slave_IO_Running.upper(), "NO")
self.assertEqual(status[0].Slave_SQL_Running.upper(), "NO")
def test_wait_for_slave(self):
"""Test wait_for_slave_thread function.
"""
# Set up replication.
master = self.master
slave = self.slave
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
# Wait for SQL Thread and IO Thread to stop. This times out.
start_slave(slave, wait=True)
self.assertRaises(_errors.TimeoutError, wait_for_slave_thread, slave,
timeout=1, wait_for_running=False)
# Wait for SQL Thread and IO Thread to start. This times out.
stop_slave(slave, wait=True)
self.assertRaises(_errors.TimeoutError, wait_for_slave_thread, slave,
timeout=1, wait_for_running=True)
master.exec_stmt("CREATE DATABASE IF NOT EXISTS test")
master.exec_stmt("USE test")
master.exec_stmt("DROP TABLE IF EXISTS test")
master.exec_stmt("CREATE TABLE test(id INTEGER)")
binlog = get_master_status(master)
binlog_file = binlog[0][0]
binlog_pos = binlog[0][1]
# Wait until the slave catches up. It returns False because
# the threads are stopped.
self.assertRaises(_errors.DatabaseError, wait_for_slave, slave,
binlog_file, binlog_pos, timeout=0)
# Wait until the slave catches up. It returns True because
# the threads are running.
start_slave(slave, wait=True)
wait_for_slave(slave, binlog_file, binlog_pos, timeout=0)
# This times out because there are no new events.
self.assertRaises(_errors.TimeoutError, wait_for_slave, slave,
binlog_file, 2 * binlog_pos, timeout=3)
stop_slave(slave, wait=True)
master.exec_stmt("DROP TABLE IF EXISTS test")
master.exec_stmt("CREATE TABLE test(id INTEGER)")
# It throws an error because the threads are stopped.
self.assertRaises(_errors.DatabaseError, sync_slave_with_master,
slave, master, timeout=0)
# Wait until the slave catches up. It does not throw an error
# because the threads are running.
start_slave(slave, wait=True)
sync_slave_with_master(slave, master, timeout=0)
# This times out because there are no new events.
gtid_executed = "%s:%s" % (str(master.uuid), "1-20")
self.assertRaises(_errors.TimeoutError, wait_for_slave_gtid, slave,
gtid_executed, timeout=3)
def test_check_rpl_health(self):
"""Test check_slave_issues() function.
"""
# Set up replication.
master = self.master
slave = self.slave
slave.disconnect()
# Try to check the health when one cannot connect to the server.
error, ret = check_slave_issues(slave)
self.assertEqual(error, True)
self.assertEqual(ret['is_not_running'], True)
# Try to check the health when change master has not been executed.
slave.connect()
error, ret = check_slave_issues(slave)
self.assertEqual(error, True)
self.assertEqual(ret['is_not_configured'], True)
# Try to check the health after executing change master.
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
error, ret = check_slave_issues(slave)
self.assertEqual(error, True)
self.assertEqual(ret['io_not_running'], True)
self.assertEqual(ret['sql_not_running'], True)
# Try to check the health after starting one thread.
start_slave(slave, wait=True, threads=(SQL_THREAD, ))
error, ret = check_slave_issues(slave)
self.assertEqual(error, True)
self.assertEqual(ret['io_not_running'], True)
# Create data and synchronize to show there is no gtid behind.
master.exec_stmt("CREATE DATABASE IF NOT EXISTS test")
master.exec_stmt("USE test")
master.exec_stmt("DROP TABLE IF EXISTS test")
master.exec_stmt("CREATE TABLE test(id INTEGER)")
start_slave(slave, wait=True, threads=(IO_THREAD, ))
sync_slave_with_master(slave, master, timeout=0)
result = check_slave_delay(slave, master)
expected_result = {
'seconds_behind': 0,
'is_not_configured': False,
'gtids_behind': 0,
'is_not_running': False,
'sql_delay': 0
}
self.assertEqual(result, expected_result)
def test_backup(self):
image = MySQLDump.backup(self.__server_1,
MySQLInstances().backup_user,
MySQLInstances().backup_passwd,
self.mysqldump_path)
MySQLDump.restore_fabric_server(self.__server_2,
MySQLInstances().restore_user,
MySQLInstances().restore_passwd,
image,
self.mysqlclient_path)
rows = self.__server_2.exec_stmt(
"SELECT NAME FROM backup_db.backup_table",
{"fetch" : True})
self.assertEqual(len(rows), 2)
self.assertEqual(rows[0][0], 'TEST 1')
self.assertEqual(rows[1][0], 'TEST 2')
def test_global_lookup(self):
"""Basic test ensuring that doing a lookup with hint as GLOBAL
returns the information of the Global Group.
"""
#create the list of the expected servers
expected_address_list = \
[MySQLInstances().get_address(0), MySQLInstances().get_address(1)]
#Perform the lookup
obtained_address_list = []
status = self.proxy.sharding.lookup_servers("1", 500, "GLOBAL")
for row in self.check_xmlrpc_iter(status):
obtained_address_list.append(row['address'])
#Ensure that the output of the lookup matches the expected list of
#servers.
self.assertEqual(set(expected_address_list),
set(obtained_address_list))
def setUp(self):
"""Creates the following topology for testing,
GROUPID1 - localhost:13001, localhost:13002 - Global Group
GROUPID2 - localhost:13003, localhost:13004 - shard 1
GROUPID3 - localhost:13005, localhost:13006 - shard 2
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
status = self.proxy.group.create("GROUPID1", "First description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID1",
MySQLInstances().get_address(0))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID1",
MySQLInstances().get_address(1))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.create("GROUPID2", "Second description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID2",
MySQLInstances().get_address(2))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID2",
MySQLInstances().get_address(3))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.create("GROUPID3", "Third description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID3",
MySQLInstances().get_address(4))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID3",
MySQLInstances().get_address(5))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID1")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID2")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID3")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.create_definition("RANGE", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID1")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(1, "GROUPID2/0,GROUPID3/1001",
"ENABLED")
self.check_xmlrpc_command_result(status)
def setUp(self):
"""Configure the existing environment
"""
from __main__ import mysqldump_path, mysqlclient_path
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid" : _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__server_1.connect()
self.__options_2 = {
"uuid" : _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address":MySQLInstances().get_address(1),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__server_1.exec_stmt("DROP DATABASE IF EXISTS backup_db")
self.__server_1.exec_stmt("CREATE DATABASE backup_db")
self.__server_1.exec_stmt("CREATE TABLE backup_db.backup_table"
"(userID INT, name VARCHAR(30))")
self.__server_1.exec_stmt("CREATE TABLE backup_db.trigger_table"
"(count INT)")
self.__server_1.exec_stmt("INSERT INTO backup_db.trigger_table "
"VALUES(0)")
self.__server_1.exec_stmt("CREATE TRIGGER backup_db.backup_table_ai"
" AFTER INSERT ON backup_db.backup_table"
" FOR EACH ROW UPDATE backup_db.trigger_table"
" SET count = count + 1")
self.__server_1.exec_stmt("INSERT INTO backup_db.backup_table "
"VALUES(101, 'TEST 1')")
self.__server_1.exec_stmt("INSERT INTO backup_db.backup_table "
"VALUES(202, 'TEST 2')")
self.__server_1.exec_stmt("CREATE INDEX i1 ON"
" backup_db.backup_table (userID)")
self.__server_1.exec_stmt("CREATE EVENT backup_db.ev1"
" ON SCHEDULE EVERY 1 DAY DO SELECT 1")
self.mysqldump_path = mysqldump_path
self.mysqlclient_path = mysqlclient_path
def test_shard_split(self):
split_cnt_1 = 0
split_cnt_2 = 0
shard_server_1 = None
shard_server_2 = None
expected_address_list_1 = \
[MySQLInstances().get_address(2), MySQLInstances().get_address(3)]
expected_address_list_2 = \
[MySQLInstances().get_address(4), MySQLInstances().get_address(5)]
status = self.proxy.sharding.split_shard("1", "GROUPID3")
self.check_xmlrpc_command_result(status)
for i in range(1, 100):
status = self.proxy.sharding.lookup_servers("db1.t1", i, "LOCAL")
obtained_uuid_list = [
info['server_uuid'] for info in self.check_xmlrpc_iter(status)
]
obtained_address_list = [
info['address'] for info in self.check_xmlrpc_iter(status)
]
try:
self.assertEqual(set(expected_address_list_1),
set(obtained_address_list))
split_cnt_1 = split_cnt_1 + 1
if shard_server_1 is None:
shard_server_1 = fetch_test_server(obtained_uuid_list[0])
except AssertionError:
self.assertEqual(set(expected_address_list_2),
set(obtained_address_list))
split_cnt_2 = split_cnt_2 + 1
if shard_server_2 is None:
shard_server_2 = fetch_test_server(obtained_uuid_list[0])
#Ensure that both the splits have been utilized.
self.assertTrue(split_cnt_1 > 0)
self.assertTrue(split_cnt_2 > 0)
shard_server_1.connect()
shard_server_2.connect()
row_cnt_shard_1 = shard_server_1.exec_stmt(
"SELECT COUNT(*) FROM db1.t1", {"fetch": True})
row_cnt_shard_2 = shard_server_2.exec_stmt(
"SELECT COUNT(*) FROM db1.t1", {"fetch": True})
#Ensure that the split has happened, the number of values in
#each shard should be less than the original.
self.assertTrue(int(row_cnt_shard_1[0][0]) < 100)
self.assertTrue(int(row_cnt_shard_2[0][0]) < 100)
#Ensure tha two new shard_ids have been generated.
hash_sharding_specifications = HashShardingSpecification.list(1)
self.assertTrue(
ShardingUtils.compare_hash_specifications(
hash_sharding_specifications[1],
HashShardingSpecification.fetch(2)))
self.assertTrue(
ShardingUtils.compare_hash_specifications(
hash_sharding_specifications[0],
HashShardingSpecification.fetch(3)))
def setUp(self):
"""Configure the existing environment
"""
self.__options_1 = {
"uuid": _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": "server_1.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__options_2 = {
"uuid": _uuid.UUID("{aa75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_2.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
self.__group_1.add_server(self.__server_2)
self.__options_3 = {
"uuid": _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__server_3.connect()
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS prune_db")
self.__server_3.exec_stmt("CREATE DATABASE prune_db")
self.__server_3.exec_stmt("CREATE TABLE prune_db.prune_table"
"(userID INT, name VARCHAR(30))")
self.__server_3.exec_stmt("INSERT INTO prune_db.prune_table "
"VALUES(101, 'TEST 1')")
self.__server_3.exec_stmt("INSERT INTO prune_db.prune_table "
"VALUES(202, 'TEST 2')")
self.__options_4 = {
"uuid": _uuid.UUID("{dd75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_4.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_3)
self.__group_2.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_3)
self.__options_5 = {
"uuid": _uuid.UUID("{ee75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__server_5.connect()
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS prune_db")
self.__server_5.exec_stmt("CREATE DATABASE prune_db")
self.__server_5.exec_stmt("CREATE TABLE prune_db.prune_table"
"(userID INT, name VARCHAR(30))")
self.__server_5.exec_stmt("INSERT INTO prune_db.prune_table "
"VALUES(101, 'TEST 1')")
self.__server_5.exec_stmt("INSERT INTO prune_db.prune_table "
"VALUES(202, 'TEST 2')")
self.__options_6 = {
"uuid": _uuid.UUID("{ff75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_6.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add(self.__group_3)
self.__group_3.add_server(self.__server_5)
self.__group_3.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_5)
group_4 = Group("GROUPID4", "4TH description.")
Group.add(group_4)
group_5 = Group("GROUPID5", "5TH description.")
Group.add(group_5)
group_6 = Group("GROUPID6", "6TH description.")
Group.add(group_6)
group_7 = Group("GROUPID7", "7TH description.")
Group.add(group_7)
group_8 = Group("GROUPID8", "8TH description.")
Group.add(group_8)
group_9 = Group("GROUPID9", "9TH description.")
Group.add(group_9)
group_10 = Group("GROUPID10", "10TH description.")
Group.add(group_10)
group_11 = Group("GROUPID11", "11TH description.")
Group.add(group_11)
group_12 = Group("GROUPID12", "12TH description.")
Group.add(group_12)
group_13 = Group("GROUPID13", "13TH description.")
Group.add(group_13)
group_14 = Group("GROUPID14", "14TH description.")
Group.add(group_14)
self.__shard_mapping_list = ShardMapping.list_shard_mapping_defn()
self.assertEquals(self.__shard_mapping_list, [])
self.__shard_mapping_id_1 = ShardMapping.define("RANGE", "GROUPID10")
self.__shard_mapping_id_2 = ShardMapping.define("RANGE", "GROUPID11")
self.__shard_mapping_id_3 = ShardMapping.define("RANGE", "GROUPID12")
#Test with sharding type values in lower case
self.__shard_mapping_id_4 = ShardMapping.define("range", "GROUPID13")
self.__shard_mapping_id_5 = ShardMapping.define("range", "GROUPID14")
self.__shard_mapping_1 = \
ShardMapping.add(self.__shard_mapping_id_1, "db1.t1", "userID1")
self.__shard_mapping_2 = \
ShardMapping.add(self.__shard_mapping_id_2, "db2.t2", "userID2")
self.__shard_mapping_3 = \
ShardMapping.add(self.__shard_mapping_id_3, "db3.t3", "userID3")
self.__shard_mapping_4 = \
ShardMapping.add(self.__shard_mapping_id_4, "db4.t4", "userID4")
self.__shard_mapping_5 = \
ShardMapping.add(self.__shard_mapping_id_5, "prune_db.prune_table",
"userID")
self.__shard_id_1 = Shards.add("GROUPID1")
self.__shard_id_2 = Shards.add("GROUPID10")
self.__shard_id_3 = Shards.add("GROUPID11")
self.__shard_id_4 = Shards.add("GROUPID4")
self.__shard_id_5 = Shards.add("GROUPID5")
self.__shard_id_6 = Shards.add("GROUPID6")
self.__shard_id_7 = Shards.add("GROUPID7")
self.__shard_id_8 = Shards.add("GROUPID8")
self.__shard_id_9 = Shards.add("GROUPID9")
self.__shard_id_10 = Shards.add("GROUPID2")
self.__shard_id_11 = Shards.add("GROUPID3")
self.__range_sharding_specification_1 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 0,
self.__shard_id_1.shard_id)
self.__range_sharding_specification_2 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 1001,
self.__shard_id_2.shard_id)
self.__range_sharding_specification_3 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 2001,
self.__shard_id_3.shard_id)
self.__range_sharding_specification_4 = RangeShardingSpecification.add(
self.__shard_mapping_2.shard_mapping_id, 3001,
self.__shard_id_4.shard_id)
self.__range_sharding_specification_5 = RangeShardingSpecification.add(
self.__shard_mapping_2.shard_mapping_id, 4001,
self.__shard_id_5.shard_id)
self.__range_sharding_specification_6 = RangeShardingSpecification.add(
self.__shard_mapping_3.shard_mapping_id, 6001,
self.__shard_id_6.shard_id)
self.__range_sharding_specification_7 = RangeShardingSpecification.add(
self.__shard_mapping_3.shard_mapping_id, 7001,
self.__shard_id_7.shard_id)
self.__range_sharding_specification_8 = RangeShardingSpecification.add(
self.__shard_mapping_4.shard_mapping_id, 8001,
self.__shard_id_8.shard_id)
self.__range_sharding_specification_9 = RangeShardingSpecification.add(
self.__shard_mapping_4.shard_mapping_id, 10001,
self.__shard_id_9.shard_id)
self.__range_sharding_specification_10 = RangeShardingSpecification.add(
self.__shard_mapping_5.shard_mapping_id, 100,
self.__shard_id_10.shard_id)
self.__range_sharding_specification_11 = RangeShardingSpecification.add(
self.__shard_mapping_5.shard_mapping_id, 201,
self.__shard_id_11.shard_id)
def setUp(self):
"""Configure the existing environment
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid": _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
tests.utils.configure_decoupled_master(self.__group_1, self.__server_1)
self.__options_2 = {
"uuid": _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(1),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_2)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_2)
self.__options_3 = {
"uuid": _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add(self.__group_3)
self.__group_3.add_server(self.__server_3)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_3)
self.__options_4 = {
"uuid": _uuid.UUID("{bb45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(3),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server4 = MySQLServer.discover_uuid(self.__options_4["address"])
self.__options_4["uuid"] = _uuid.UUID(uuid_server4)
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__group_4 = Group("GROUPID4", "Fourth description.")
Group.add(self.__group_4)
self.__group_4.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_4, self.__server_4)
self.__options_5 = {
"uuid": _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(4),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__group_5 = Group("GROUPID5", "Fifth description.")
Group.add(self.__group_5)
self.__group_5.add_server(self.__server_5)
tests.utils.configure_decoupled_master(self.__group_5, self.__server_5)
self.__options_6 = {
"uuid": _uuid.UUID("{cc45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(5),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server6 = MySQLServer.discover_uuid(self.__options_6["address"])
self.__options_6["uuid"] = _uuid.UUID(uuid_server6)
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__group_6 = Group("GROUPID6", "Sixth description.")
Group.add(self.__group_6)
self.__group_6.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_6, self.__server_6)
status = self.proxy.sharding.create_definition("HASH", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID1")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(
1, "GROUPID2,GROUPID3,"
"GROUPID4,GROUPID5,GROUPID6", "ENABLED")
self.check_xmlrpc_command_result(status)
def setUp(self):
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid": _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
tests.utils.configure_decoupled_master(self.__group_1, self.__server_1)
self.__options_2 = {
"uuid": _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(1),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_2.exec_stmt("CREATE DATABASE db1")
self.__server_2.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 501):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_2)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_2)
self.__options_3 = {
"uuid": _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__server_3.connect()
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_3.exec_stmt("CREATE DATABASE db1")
self.__server_3.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 501):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add(self.__group_3)
self.__group_3.add_server(self.__server_3)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_3)
self.__options_4 = {
"uuid": _uuid.UUID("{bb45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(3),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server4 = MySQLServer.discover_uuid(self.__options_4["address"])
self.__options_4["uuid"] = _uuid.UUID(uuid_server4)
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__server_4.connect()
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_4.exec_stmt("CREATE DATABASE db1")
self.__server_4.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 501):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_4 = Group("GROUPID4", "Fourth description.")
Group.add(self.__group_4)
self.__group_4.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_4, self.__server_4)
self.__options_5 = {
"uuid": _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(4),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__server_5.connect()
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_5.exec_stmt("CREATE DATABASE db1")
self.__server_5.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 501):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_5 = Group("GROUPID5", "Fifth description.")
Group.add(self.__group_5)
self.__group_5.add_server(self.__server_5)
tests.utils.configure_decoupled_master(self.__group_5, self.__server_5)
self.__options_6 = {
"uuid": _uuid.UUID("{cc45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(5),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server6 = MySQLServer.discover_uuid(self.__options_6["address"])
self.__options_6["uuid"] = _uuid.UUID(uuid_server6)
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__server_6.connect()
self.__server_6.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_6.exec_stmt("CREATE DATABASE db1")
self.__server_6.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 501):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_6 = Group("GROUPID6", "Sixth description.")
Group.add(self.__group_6)
self.__group_6.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_6, self.__server_6)
self.__shard_mapping_list = ShardMapping.list_shard_mapping_defn()
self.assertEquals(self.__shard_mapping_list, [])
self.__shard_mapping_id_1 = ShardMapping.define("HASH", "GROUPID1")
self.__shard_mapping_1 = ShardMapping.add(self.__shard_mapping_id_1,
"db1.t1", "userID")
self.__shard_1 = Shards.add("GROUPID2")
self.__shard_2 = Shards.add("GROUPID3")
self.__shard_3 = Shards.add("GROUPID4")
self.__shard_4 = Shards.add("GROUPID5")
self.__shard_5 = Shards.add("GROUPID6")
self.__hash_sharding_specification_1 = HashShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, self.__shard_1.shard_id)
self.__hash_sharding_specification_2 = HashShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, self.__shard_2.shard_id)
self.__hash_sharding_specification_3 = HashShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, self.__shard_3.shard_id)
self.__hash_sharding_specification_4 = HashShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, self.__shard_4.shard_id)
self.__hash_sharding_specification_5 = HashShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, self.__shard_5.shard_id)
def setUp(self):
"""Create the setup for performing the testing of the server clone
command.
"""
_LOGGER.critical("\n\nStart of test-fixture-SetUp(): %s\n" %
(self._testMethodName))
from __main__ import mysqldump_path, mysqlclient_path
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid": _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__server_1.connect()
self.__options_2 = {
"uuid": _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(1),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__options_3 = {
"uuid": _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__server_3.connect()
#Insert data into Server 1
self.__server_1.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_1.exec_stmt("CREATE DATABASE db1")
self.__server_1.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
self.__server_1.exec_stmt("INSERT INTO db1.t1 "
"VALUES(101, 'TEST 1')")
self.__server_1.exec_stmt("INSERT INTO db1.t1 "
"VALUES(202, 'TEST 2')")
self.__server_1.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_1.exec_stmt("CREATE DATABASE db2")
self.__server_1.exec_stmt("CREATE TABLE db2.t1"
"(userID INT, name VARCHAR(30))")
self.__server_1.exec_stmt("INSERT INTO db2.t1 "
"VALUES(101, 'TEST 1')")
self.__server_1.exec_stmt("INSERT INTO db2.t1 "
"VALUES(202, 'TEST 2')")
_LOGGER.debug("End of test-fixture-SetUp(): %s\n" %
(self._testMethodName))
def setUp(self):
"""Creates the topology for testing.
"""
tests.utils.cleanup_environment()
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid" : _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(0),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__server_1.connect()
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
tests.utils.configure_decoupled_master(self.__group_1, self.__server_1)
self.__options_2 = {
"uuid" : _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(1),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_2.exec_stmt("CREATE DATABASE db1")
self.__server_2.exec_stmt("CREATE TABLE db1.t1"
"(userID VARCHAR(20) PRIMARY KEY, name VARCHAR(30))")
for i in range(1, 71):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("e"+str(i), i))
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_2.exec_stmt("CREATE DATABASE db2")
self.__server_2.exec_stmt("CREATE TABLE db2.t2"
"(userID VARCHAR(20), salary INT, "
"CONSTRAINT FOREIGN KEY(userID) "
"REFERENCES db1.t1(userID))")
for i in range(1, 71):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("e"+str(i), i))
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_2)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_2)
self.__options_3 = {
"uuid" : _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(2),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add( self.__server_3)
self.__server_3.connect()
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_3.exec_stmt("CREATE DATABASE db1")
self.__server_3.exec_stmt("CREATE TABLE db1.t1"
"(userID VARCHAR(20)PRIMARY KEY, name VARCHAR(30))")
for i in range(1, 71):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("e"+str(i), i))
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_3.exec_stmt("CREATE DATABASE db2")
self.__server_3.exec_stmt("CREATE TABLE db2.t2"
"(userID VARCHAR(20), salary INT, "
"CONSTRAINT FOREIGN KEY(userID) "
"REFERENCES db1.t1(userID))")
for i in range(1, 71):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("e"+str(i), i))
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add( self.__group_3)
self.__group_3.add_server(self.__server_3)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_3)
self.__options_4 = {
"uuid" : _uuid.UUID("{bb45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(3),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server4 = MySQLServer.discover_uuid(self.__options_4["address"])
self.__options_4["uuid"] = _uuid.UUID(uuid_server4)
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__server_4.connect()
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_4.exec_stmt("CREATE DATABASE db1")
self.__server_4.exec_stmt("CREATE TABLE db1.t1"
"(userID VARCHAR(20)PRIMARY KEY, name VARCHAR(30))")
for i in range(1, 71):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("e"+str(i), i))
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_4.exec_stmt("CREATE DATABASE db2")
self.__server_4.exec_stmt("CREATE TABLE db2.t2"
"(userID VARCHAR(20), salary INT, "
"CONSTRAINT FOREIGN KEY(userID) "
"REFERENCES db1.t1(userID))")
for i in range(1, 71):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("e"+str(i), i))
self.__group_4 = Group("GROUPID4", "Fourth description.")
Group.add( self.__group_4)
self.__group_4.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_4, self.__server_4)
self.__options_5 = {
"uuid" : _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(4),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__server_5.connect()
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_5.exec_stmt("CREATE DATABASE db1")
self.__server_5.exec_stmt("CREATE TABLE db1.t1"
"(userID VARCHAR(20)PRIMARY KEY, name VARCHAR(30))")
for i in range(1, 71):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES('%s', 'TEST %s')" % ("e"+str(i), i))
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_5.exec_stmt("CREATE DATABASE db2")
self.__server_5.exec_stmt("CREATE TABLE db2.t2"
"(userID VARCHAR(20), salary INT, "
"CONSTRAINT FOREIGN KEY(userID) "
"REFERENCES db1.t1(userID))")
for i in range(1, 71):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("a"+str(i), i))
for i in range(101, 301):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("b"+str(i), i))
for i in range(1001, 1201):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("c"+str(i), i))
for i in range(10001, 10201):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("d"+str(i), i))
for i in range(100001, 100201):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES('%s', %s)" % ("e"+str(i), i))
self.__group_5 = Group("GROUPID5", "Fifth description.")
Group.add( self.__group_5)
self.__group_5.add_server(self.__server_5)
tests.utils.configure_decoupled_master(self.__group_5, self.__server_5)
self.__options_6 = {
"uuid" : _uuid.UUID("{cc45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(5),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server6 = MySQLServer.discover_uuid(self.__options_6["address"])
self.__options_6["uuid"] = _uuid.UUID(uuid_server6)
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__server_6.connect()
self.__group_6 = Group("GROUPID6", "Sixth description.")
Group.add( self.__group_6)
self.__group_6.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_6, self.__server_6)
status = self.proxy.sharding.create_definition("RANGE_STRING", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_table(1, "db2.t2", "userID")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(
1,
"GROUPID2/a,GROUPID3/b,GROUPID4/c,GROUPID5/d",
"ENABLED"
)
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.prune_shard("db1.t1")
self.check_xmlrpc_command_result(status)
def setUp(self):
"""Configure the existing environment
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid": _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": "server_1.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__options_2 = {
"uuid": _uuid.UUID("{aa75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_2.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
self.__group_1.add_server(self.__server_2)
self.__options_3 = {
"uuid": _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__options_4 = {
"uuid": _uuid.UUID("{dd75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_4.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_3)
self.__group_2.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_3)
self.__options_5 = {
"uuid": _uuid.UUID("{ee75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__options_6 = {
"uuid": _uuid.UUID("{ff75a12a-98d1-414c-96af-9e9d4b179678}"),
"address": "server_6.mysql.com:3060",
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add(self.__group_3)
self.__group_3.add_server(self.__server_5)
self.__group_3.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_5)
self.__options_1_host, self.__options_1_port = \
server_utils.split_host_port(self.__options_1["address"], 13001)
self.__options_2_host, self.__options_2_port = \
server_utils.split_host_port(self.__options_2["address"], 13001)
self.__options_3_host, self.__options_3_port = \
server_utils.split_host_port(self.__options_3["address"], 13001)
self.__options_4_host, self.__options_4_port = \
server_utils.split_host_port(self.__options_4["address"], 13001)
self.__options_5_host, self.__options_5_port = \
server_utils.split_host_port(self.__options_5["address"], 13001)
self.__options_6_host, self.__options_6_port = \
server_utils.split_host_port(self.__options_6["address"], 13001)
group_4 = Group("GROUPID4", "4TH description.")
Group.add(group_4)
group_5 = Group("GROUPID5", "5TH description.")
Group.add(group_5)
group_6 = Group("GROUPID6", "6TH description.")
Group.add(group_6)
group_7 = Group("GROUPID7", "7TH description.")
Group.add(group_7)
group_8 = Group("GROUPID8", "8TH description.")
Group.add(group_8)
group_9 = Group("GROUPID9", "9TH description.")
Group.add(group_9)
group_10 = Group("GROUPID10", "10TH description.")
Group.add(group_10)
group_11 = Group("GROUPID11", "11TH description.")
Group.add(group_11)
group_12 = Group("GROUPID12", "12TH description.")
Group.add(group_12)
group_13 = Group("GROUPID13", "13TH description.")
Group.add(group_13)
group_14 = Group("GROUPID14", "14TH description.")
Group.add(group_14)
self.__shard_mapping_list = ShardMapping.list_shard_mapping_defn()
self.assertEquals(self.__shard_mapping_list, [])
self.__shard_mapping_id_1 = ShardMapping.define("RANGE", "GROUPID10")
self.__shard_mapping_id_2 = ShardMapping.define("RANGE", "GROUPID11")
self.__shard_mapping_id_3 = ShardMapping.define("RANGE", "GROUPID12")
#Test with sharding type values in lower case
self.__shard_mapping_id_4 = ShardMapping.define("range", "GROUPID13")
self.__shard_mapping_id_5 = ShardMapping.define("range", "GROUPID14")
self.__shard_mapping_1 = \
ShardMapping.add(self.__shard_mapping_id_1, "db1.t1", "userID1")
self.__shard_mapping_2 = \
ShardMapping.add(self.__shard_mapping_id_2, "db2.t2", "userID2")
self.__shard_mapping_3 = \
ShardMapping.add(self.__shard_mapping_id_3, "db3.t3", "userID3")
self.__shard_mapping_4 = \
ShardMapping.add(self.__shard_mapping_id_4, "db4.t4", "userID4")
self.__shard_mapping_5 = \
ShardMapping.add(self.__shard_mapping_id_5, "prune_db.prune_table",
"userID")
self.__shard_id_1 = Shards.add("GROUPID1", "ENABLED")
self.__shard_id_2 = Shards.add("GROUPID10", "ENABLED")
self.__shard_id_3 = Shards.add("GROUPID11", "DISABLED")
self.__shard_id_4 = Shards.add("GROUPID4", "ENABLED")
self.__shard_id_5 = Shards.add("GROUPID5", "ENABLED")
self.__shard_id_6 = Shards.add("GROUPID6", "ENABLED")
self.__shard_id_7 = Shards.add("GROUPID7", "ENABLED")
self.__shard_id_8 = Shards.add("GROUPID8", "ENABLED")
self.__shard_id_9 = Shards.add("GROUPID9", "ENABLED")
self.__shard_id_10 = Shards.add("GROUPID2", "ENABLED")
self.__shard_id_11 = Shards.add("GROUPID3", "ENABLED")
self.__range_sharding_specification_1 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 0,
self.__shard_id_1.shard_id)
self.__range_sharding_specification_2 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 1001,
self.__shard_id_2.shard_id)
self.__range_sharding_specification_3 = RangeShardingSpecification.add(
self.__shard_mapping_1.shard_mapping_id, 2001,
self.__shard_id_3.shard_id)
self.__range_sharding_specification_4 = RangeShardingSpecification.add(
self.__shard_mapping_2.shard_mapping_id, 3001,
self.__shard_id_4.shard_id)
self.__range_sharding_specification_5 = RangeShardingSpecification.add(
self.__shard_mapping_2.shard_mapping_id, 4001,
self.__shard_id_5.shard_id)
self.__range_sharding_specification_6 = RangeShardingSpecification.add(
self.__shard_mapping_3.shard_mapping_id, 6001,
self.__shard_id_6.shard_id)
self.__range_sharding_specification_7 = RangeShardingSpecification.add(
self.__shard_mapping_3.shard_mapping_id, 7001,
self.__shard_id_7.shard_id)
self.__range_sharding_specification_8 = RangeShardingSpecification.add(
self.__shard_mapping_4.shard_mapping_id, 8001,
self.__shard_id_8.shard_id)
self.__range_sharding_specification_9 = RangeShardingSpecification.add(
self.__shard_mapping_4.shard_mapping_id, 10001,
self.__shard_id_9.shard_id)
self.__range_sharding_specification_10 = RangeShardingSpecification.add(
self.__shard_mapping_5.shard_mapping_id, 100,
self.__shard_id_10.shard_id)
self.__range_sharding_specification_11 = RangeShardingSpecification.add(
self.__shard_mapping_5.shard_mapping_id, 201,
self.__shard_id_11.shard_id)
READ_ONLY = MySQLServer.get_mode_idx(MySQLServer.READ_ONLY)
READ_WRITE = MySQLServer.get_mode_idx(MySQLServer.READ_WRITE)
SECONDARY = MySQLServer.get_status_idx(MySQLServer.SECONDARY)
PRIMARY = MySQLServer.get_status_idx(MySQLServer.PRIMARY)
self.__setofservers = tests.utils.make_servers_result(
[[
str(self.__server_1.uuid), 'GROUPID1', self.__options_1_host,
self.__options_1_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_2.uuid), 'GROUPID1', self.__options_2_host,
self.__options_2_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_3.uuid), 'GROUPID2', self.__options_3_host,
self.__options_3_port, READ_WRITE, PRIMARY, 1.0
],
[
str(self.__server_4.uuid), 'GROUPID2', self.__options_4_host,
self.__options_4_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_5.uuid), 'GROUPID3', self.__options_5_host,
self.__options_5_port, READ_WRITE, PRIMARY, 1.0
],
[
str(self.__server_6.uuid), 'GROUPID3', self.__options_6_host,
self.__options_6_port, READ_ONLY, SECONDARY, 1.0
]])
self.__setofservers_1 = tests.utils.make_servers_result(
[[
str(self.__server_1.uuid), 'GROUPID1', self.__options_1_host,
self.__options_1_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_2.uuid), 'GROUPID1', self.__options_2_host,
self.__options_2_port, READ_ONLY, SECONDARY, 1.0
]])
self.__setofservers_2 = tests.utils.make_servers_result(
[[
str(self.__server_1.uuid), 'GROUPID1', self.__options_1_host,
self.__options_1_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_2.uuid), 'GROUPID1', self.__options_2_host,
self.__options_2_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_3.uuid), 'GROUPID2', self.__options_3_host,
self.__options_3_port, READ_WRITE, PRIMARY, 1.0
],
[
str(self.__server_4.uuid), 'GROUPID2', self.__options_4_host,
self.__options_4_port, READ_ONLY, SECONDARY, 1.0
]])
self.__setofservers_3 = tests.utils.make_servers_result(
[[
str(self.__server_1.uuid), 'GROUPID1', self.__options_1_host,
self.__options_1_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_2.uuid), 'GROUPID1', self.__options_2_host,
self.__options_2_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_3.uuid), 'GROUPID2', self.__options_3_host,
self.__options_3_port, READ_WRITE, PRIMARY, 1.0
],
[
str(self.__server_4.uuid), 'GROUPID2', self.__options_4_host,
self.__options_4_port, READ_ONLY, SECONDARY, 1.0
],
[
str(self.__server_5.uuid), 'GROUPID3', self.__options_5_host,
self.__options_5_port, READ_WRITE, PRIMARY, 1.0
],
[
str(self.__server_6.uuid), 'GROUPID3', self.__options_6_host,
self.__options_6_port, READ_ONLY, SECONDARY, 1.0
]])
self.__setoftables = tests.utils.make_tables_result(
[['db1', 't1', 'userID1', '1'], ['db2', 't2', 'userID2', '2'],
['db3', 't3', 'userID3', '3'], ['db4', 't4', 'userID4', '4'],
['prune_db', 'prune_table', 'userID', '5']])
self.__setoftables_1 = tests.utils.make_tables_result(
[['db1', 't1', 'userID1', '1']])
self.__setoftables_2 = tests.utils.make_tables_result(
[['db1', 't1', 'userID1', '1'], ['db2', 't2', 'userID2', '2']])
self.__setoftables_3 = tests.utils.make_tables_result(
[['db1', 't1', 'userID1', '1'], ['db2', 't2', 'userID2', '2'],
['db3', 't3', 'userID3', '3']])
self.__setofshardmaps = tests.utils.make_mapping_result(
[['1', 'RANGE', 'GROUPID10'], ['2', 'RANGE', 'GROUPID11'],
['3', 'RANGE', 'GROUPID12'], ['4', 'RANGE', 'GROUPID13'],
['5', 'RANGE', 'GROUPID14']])
self.__setofshardmaps_1 = tests.utils.make_mapping_result(
[['1', 'RANGE', 'GROUPID10']])
self.__setofshardmaps_2 = tests.utils.make_mapping_result(
[['1', 'RANGE', 'GROUPID10'], ['2', 'RANGE', 'GROUPID11']])
self.__setofshardmaps_3 = tests.utils.make_mapping_result(
[['1', 'RANGE', 'GROUPID10'], ['2', 'RANGE', 'GROUPID11'],
['3', 'RANGE', 'GROUPID12']])
self.__setofshardindexes = tests.utils.make_index_result(
[['0', '1', '1', 'GROUPID1'], ['1001', '1', '2', 'GROUPID10'],
['3001', '2', '4', 'GROUPID4'], ['4001', '2', '5', 'GROUPID5'],
['6001', '3', '6', 'GROUPID6'], ['7001', '3', '7', 'GROUPID7'],
['8001', '4', '8', 'GROUPID8'], ['10001', '4', '9', 'GROUPID9'],
['100', '5', '10', 'GROUPID2'], ['201', '5', '11', 'GROUPID3']])
self.__setofshardindexes_1 = tests.utils.make_index_result(
[['0', '1', '1', 'GROUPID1'], ['1001', '1', '2', 'GROUPID10']])
self.__setofshardindexes_3 = tests.utils.make_index_result(
[['0', '1', '1', 'GROUPID1'], ['1001', '1', '2', 'GROUPID10'],
['3001', '2', '4', 'GROUPID4'], ['4001', '2', '5', 'GROUPID5'],
['6001', '3', '6', 'GROUPID6'], ['7001', '3', '7', 'GROUPID7']])
self.__setofshardindexes_5 = tests.utils.make_index_result(
[['0', '1', '1', 'GROUPID1'], ['1001', '1', '2', 'GROUPID10'],
['3001', '2', '4', 'GROUPID4'], ['4001', '2', '5', 'GROUPID5'],
['6001', '3', '6', 'GROUPID6'], ['7001', '3', '7', 'GROUPID7'],
['8001', '4', '8', 'GROUPID8'], ['10001', '4', '9', 'GROUPID9'],
['100', '5', '10', 'GROUPID2'], ['201', '5', '11', 'GROUPID3']])
self.__shardinginformation_1 = tests.utils.make_info_result(
[[
'db1', 't1', 'userID1', '0', '1', 'RANGE', 'GROUPID1',
'GROUPID10'
],
[
'db1', 't1', 'userID1', '1001', '2', 'RANGE', 'GROUPID10',
'GROUPID10'
]])
self.__shardinginformation_2 = tests.utils.make_info_result(
[[
'db1', 't1', 'userID1', '0', '1', 'RANGE', 'GROUPID1',
'GROUPID10'
],
[
'db1', 't1', 'userID1', '1001', '2', 'RANGE', 'GROUPID10',
'GROUPID10'
],
[
'db2', 't2', 'userID2', '3001', '4', 'RANGE', 'GROUPID4',
'GROUPID11'
],
[
'db2', 't2', 'userID2', '4001', '5', 'RANGE', 'GROUPID5',
'GROUPID11'
]])
self.__shardinginformation_3 = tests.utils.make_info_result(
[[
'db1', 't1', 'userID1', '0', '1', 'RANGE', 'GROUPID1',
'GROUPID10'
],
[
'db1', 't1', 'userID1', '1001', '2', 'RANGE', 'GROUPID10',
'GROUPID10'
],
[
'db2', 't2', 'userID2', '3001', '4', 'RANGE', 'GROUPID4',
'GROUPID11'
],
[
'db2', 't2', 'userID2', '4001', '5', 'RANGE', 'GROUPID5',
'GROUPID11'
],
[
'db3', 't3', 'userID3', '6001', '6', 'RANGE', 'GROUPID6',
'GROUPID12'
],
[
'db3', 't3', 'userID3', '7001', '7', 'RANGE', 'GROUPID7',
'GROUPID12'
]])
import uuid as _uuid
from mysql.fabric import errors as _errors
from mysql.fabric.server import MySQLServer
from mysql.fabric.replication import *
from tests.utils import (
MySQLInstances,
cleanup_environment,
)
import tests.utils
OPTIONS_MASTER = {
"uuid" : _uuid.UUID("80139491-08ed-11e2-b7bd-f0def124dcc5"),
"address" : MySQLInstances().get_address(0),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
OPTIONS_SLAVE = {
"uuid" : _uuid.UUID("811f03ff-08ed-11e2-b7bd-f0def124dcc5"),
"address" : MySQLInstances().get_address(1),
"user" : MySQLInstances().user,
"passwd": MySQLInstances().passwd,
}
class TestMySQLMaster(tests.utils.TestCase):
"""Unit test for the configuration file handling.
"""
def setUp(self):
def test_get_gtid_behind(self):
"""Test get_gtid_behind() function.
"""
# Set up replication.
master = self.master
slave = self.slave
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
# Check gtid that has no information on server_uuid.
self.assertRaises(_errors.ProgrammingError, get_num_gtid, "1")
sid_1 = "80139491-08ed-11e2-b7bd-f0def124dcc5"
sid_2 = "99939491-08ed-11e2-b7bd-f0def124dcc5"
# Check the pattern sid:trx_id.
ret = get_num_gtid("%s:%s" % (sid_1, "5"))
self.assertEqual(ret, 1)
# Check the pattern sid:trx_id-trx_id.
ret = get_num_gtid("%s:%s" % (sid_1, "5-10"))
self.assertEqual(ret, 6)
# Check the pattern sid:trx_id-trx_id, trx_id, trx_id-trx-id.
ret = get_num_gtid("%s:%s,%s,%s" % (sid_1, "5-10", "20", "25-30"))
self.assertEqual(ret, 13)
# Check the pattern sid:trx_id-trx_id, sid:trx_id-trx-id.
ret = get_num_gtid("%s:%s,%s:%s" % (sid_1, "5-10", sid_2, "5-6"))
self.assertEqual(ret, 8)
# Check the pattern sid:trx_id-trx_id, sid:trx_id-trx-id but filtering
# server_uuids that are different from sid_2.
ret = get_num_gtid("%s:%s,%s:%s" %
(sid_1, "5-10", sid_2, "5-6"), sid_2)
self.assertEqual(ret, 2)
# Check empty master_gtid_status and empty slave_gtid_status.
master_gtid_status = master.get_gtid_status()
slave_gtid_status = slave.get_gtid_status()
ret = get_slave_num_gtid_behind(slave, master_gtid_status)
self.assertEqual(ret, 0)
self.assertEqual(slave_gtid_status[0].GTID_EXECUTED, "")
self.assertEqual(master_gtid_status[0].GTID_EXECUTED, "")
# It is not possible to do any comparison if the master_gtid_status
# is empty.
slave.exec_stmt("CREATE DATABASE IF NOT EXISTS test")
slave.exec_stmt("USE test")
slave.exec_stmt("DROP TABLE IF EXISTS test")
master_gtid_status = master.get_gtid_status()
slave_gtid_status = slave.get_gtid_status()
self.assertRaises(_errors.InvalidGtidError, get_slave_num_gtid_behind,
slave, master_gtid_status)
self.assertNotEqual(slave_gtid_status[0].GTID_EXECUTED, "")
self.assertEqual(master_gtid_status[0].GTID_EXECUTED, "")
# Check what happens if there are different sets of transactions.
master.exec_stmt("CREATE DATABASE IF NOT EXISTS test")
master_gtid_status = master.get_gtid_status()
slave_gtid_status = slave.get_gtid_status()
ret = get_slave_num_gtid_behind(slave, master_gtid_status)
self.assertEqual(ret, 1)
self.assertNotEqual(slave_gtid_status[0].GTID_EXECUTED, "")
self.assertNotEqual(master_gtid_status[0].GTID_EXECUTED, "")
# Check what happens if the slave_gtid_status is empty.
reset_master(slave)
master_gtid_status = master.get_gtid_status()
slave_gtid_status = slave.get_gtid_status()
ret = get_slave_num_gtid_behind(slave, master_gtid_status)
self.assertEqual(ret, 1)
self.assertEqual(slave_gtid_status[0].GTID_EXECUTED, "")
self.assertNotEqual(master_gtid_status[0].GTID_EXECUTED, "")
def test_switch_master_(self):
"""Test the switch_master() function.
"""
# Note this is only being tested with gtids.
# Set up replication.
master = self.master
slave = self.slave
# Check that is slave is not connected to any master.
self.assertFalse(is_slave_thread_running(slave, (IO_THREAD, )))
self.assertNotEqual(slave_has_master(slave), str(master.uuid))
# Switch to a master.
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd)
start_slave(slave, wait=True)
self.assertTrue(is_slave_thread_running(slave, (IO_THREAD, )))
# The IO_THREAD status and the UUID are not atomically updated
# for that reason master_uuid can be None.
master_uuid = slave_has_master(slave)
self.assertTrue(
master_uuid == None or master_uuid == str(master.uuid)
)
# It is not possible to switch when replication is running.
self.assertRaises(_errors.DatabaseError, switch_master, slave,
master, MySQLInstances().user, MySQLInstances().passwd
)
# Reset and try to reconnect master and slave.
stop_slave(slave, wait=True)
reset_slave(slave, clean=True)
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
start_slave(slave, wait=True)
self.assertTrue(is_slave_thread_running(slave, (IO_THREAD, )))
self.assertEqual(slave_has_master(slave), str(master.uuid))
# Change master's password, reset and try to reconnect master
# and slave.
stop_slave(slave, wait=True)
master.set_session_binlog(False)
master.exec_stmt(
"SET PASSWORD = PASSWORD('foobar')"
)
master.set_session_binlog(True)
switch_master(slave, master, MySQLInstances().user, "foobar")
start_slave(slave, wait=True)
self.assertTrue(is_slave_thread_running(slave, (IO_THREAD, )))
self.assertEqual(slave_has_master(slave), str(master.uuid))
# Reset master's password, reset and try to reconnect master
# and slave.
stop_slave(slave, wait=True)
master.set_session_binlog(False)
master.exec_stmt(
"SET PASSWORD = PASSWORD('{passwd}')".format(
passwd=MySQLInstances().passwd or "")
)
master.set_session_binlog(True)
switch_master(slave, master, MySQLInstances().user,
MySQLInstances().passwd
)
start_slave(slave, wait=True)
self.assertTrue(is_slave_thread_running(slave, (IO_THREAD, )))
self.assertEqual(slave_has_master(slave), str(master.uuid))
def setUp(self):
"""Configure the existing environment
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid" : _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(0),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
tests.utils.configure_decoupled_master(self.__group_1, self.__server_1)
self.__options_2 = {
"uuid" : _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(1),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_2.exec_stmt("CREATE DATABASE db1")
self.__server_2.exec_stmt("CREATE TABLE db1.t1"
"(userID1 INT, name VARCHAR(30))")
for i in range(1, 201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_2.exec_stmt("CREATE DATABASE db2")
self.__server_2.exec_stmt("CREATE TABLE db2.t2"
"(userID2 INT, name VARCHAR(30))")
for i in range(201, 401):
self.__server_2.exec_stmt("INSERT INTO db2.t2 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db3")
self.__server_2.exec_stmt("CREATE DATABASE db3")
self.__server_2.exec_stmt("CREATE TABLE db3.t3"
"(userID3 INT, name VARCHAR(30))")
for i in range(401, 601):
self.__server_2.exec_stmt("INSERT INTO db3.t3 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_2)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_2)
self.__options_3 = {
"uuid" : _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(2),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add( self.__server_3)
self.__server_3.connect()
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_3.exec_stmt("CREATE DATABASE db1")
self.__server_3.exec_stmt("CREATE TABLE db1.t1"
"(userID1 INT, name VARCHAR(30))")
for i in range(1, 201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_3.exec_stmt("CREATE DATABASE db2")
self.__server_3.exec_stmt("CREATE TABLE db2.t2"
"(userID2 INT, name VARCHAR(30))")
for i in range(201, 401):
self.__server_3.exec_stmt("INSERT INTO db2.t2 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db3")
self.__server_3.exec_stmt("CREATE DATABASE db3")
self.__server_3.exec_stmt("CREATE TABLE db3.t3"
"(userID3 INT, name VARCHAR(30))")
for i in range(401, 601):
self.__server_3.exec_stmt("INSERT INTO db3.t3 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add( self.__group_3)
self.__group_3.add_server(self.__server_3)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_3)
self.__options_4 = {
"uuid" : _uuid.UUID("{bb45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(3),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server4 = MySQLServer.discover_uuid(self.__options_4["address"])
self.__options_4["uuid"] = _uuid.UUID(uuid_server4)
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__server_4.connect()
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_4.exec_stmt("CREATE DATABASE db1")
self.__server_4.exec_stmt("CREATE TABLE db1.t1"
"(userID1 INT, name VARCHAR(30))")
for i in range(1, 201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_4.exec_stmt("CREATE DATABASE db2")
self.__server_4.exec_stmt("CREATE TABLE db2.t2"
"(userID2 INT, name VARCHAR(30))")
for i in range(201, 401):
self.__server_4.exec_stmt("INSERT INTO db2.t2 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db3")
self.__server_4.exec_stmt("CREATE DATABASE db3")
self.__server_4.exec_stmt("CREATE TABLE db3.t3"
"(userID3 INT, name VARCHAR(30))")
for i in range(401, 601):
self.__server_4.exec_stmt("INSERT INTO db3.t3 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_4 = Group("GROUPID4", "Fourth description.")
Group.add( self.__group_4)
self.__group_4.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_4, self.__server_4)
self.__options_5 = {
"uuid" : _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(4),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__server_5.connect()
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_5.exec_stmt("CREATE DATABASE db1")
self.__server_5.exec_stmt("CREATE TABLE db1.t1"
"(userID1 INT, name VARCHAR(30))")
for i in range(1, 201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_5.exec_stmt("CREATE DATABASE db2")
self.__server_5.exec_stmt("CREATE TABLE db2.t2"
"(userID2 INT, name VARCHAR(30))")
for i in range(201, 401):
self.__server_5.exec_stmt("INSERT INTO db2.t2 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db3")
self.__server_5.exec_stmt("CREATE DATABASE db3")
self.__server_5.exec_stmt("CREATE TABLE db3.t3"
"(userID3 INT, name VARCHAR(30))")
for i in range(401, 601):
self.__server_5.exec_stmt("INSERT INTO db3.t3 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_5 = Group("GROUPID5", "Fifth description.")
Group.add( self.__group_5)
self.__group_5.add_server(self.__server_5)
tests.utils.configure_decoupled_master(self.__group_5, self.__server_5)
self.__options_6 = {
"uuid" : _uuid.UUID("{cc45b12b-98d1-414c-96af-9e9d4b179678}"),
"address" : MySQLInstances().get_address(5),
"user" : MySQLInstances().user,
"passwd" : MySQLInstances().passwd,
}
uuid_server6 = MySQLServer.discover_uuid(self.__options_6["address"])
self.__options_6["uuid"] = _uuid.UUID(uuid_server6)
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__server_6.connect()
self.__server_6.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_6.exec_stmt("CREATE DATABASE db1")
self.__server_6.exec_stmt("CREATE TABLE db1.t1"
"(userID1 INT, name VARCHAR(30))")
for i in range(1, 201):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_6.exec_stmt("DROP DATABASE IF EXISTS db2")
self.__server_6.exec_stmt("CREATE DATABASE db2")
self.__server_6.exec_stmt("CREATE TABLE db2.t2"
"(userID2 INT, name VARCHAR(30))")
for i in range(201, 401):
self.__server_6.exec_stmt("INSERT INTO db2.t2 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__server_6.exec_stmt("DROP DATABASE IF EXISTS db3")
self.__server_6.exec_stmt("CREATE DATABASE db3")
self.__server_6.exec_stmt("CREATE TABLE db3.t3"
"(userID3 INT, name VARCHAR(30))")
for i in range(401, 601):
self.__server_6.exec_stmt("INSERT INTO db3.t3 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_6 = Group("GROUPID6", "Sixth description.")
Group.add( self.__group_6)
self.__group_6.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_6, self.__server_6)
status = self.proxy.sharding.create_definition("HASH", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID1")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_table(1, "db2.t2", "userID2")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_table(1, "db3.t3", "userID3")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(
1,
"GROUPID2,GROUPID3,GROUPID4,GROUPID5,GROUPID6",
"ENABLED"
)
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.prune_shard("db1.t1")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.prune_shard("db2.t2")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.prune_shard("db3.t3")
self.check_xmlrpc_command_result(status)
def test_server_permissions(self):
"""Verify the server user permissions.
"""
#
# Skip test in trial-mode. Users are the same a s admin user.
# Admin won't be able to grant a privilege back to itself.
#
if (MySQLInstances().server_user == MySQLInstances().user):
# The trailing comma prevents a newline.
print "Skipping test_server_permissions in trial-mode --- ",
return
#
# Prepare group and servers
#
self.proxy.group.create("group", "Testing group...")
address_0 = tests.utils.MySQLInstances().get_address(0)
address_1 = tests.utils.MySQLInstances().get_address(1)
address_2 = tests.utils.MySQLInstances().get_address(2)
status_uuid = self.proxy.server.lookup_uuid(address_0)
uuid_0 = status_uuid[2]
status_uuid = self.proxy.server.lookup_uuid(address_1)
uuid_1 = status_uuid[2]
status_uuid = self.proxy.server.lookup_uuid(address_2)
uuid_2 = status_uuid[2]
status = self.proxy.group.add("group", address_0)
self.check_xmlrpc_command_result(status, False)
server_0 = fetch_test_server(address_0)
server_0.connect()
#
# Change password of the the server user, remove server from
# group, try to add server to group, which fails, because the
# Fabric instance does still use the old password, change
# password back, add server to group. The remove operation is
# required, so that fabric purges all connections to this
# server. Otherwise it would use existing connections, which do
# not care about a changed password. Only the add server to
# group command after a remove server from group cpmmand forces
# Fabric to establish a new connection, which fails on the wrong
# password.
#
server_0.exec_stmt(
"SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('foobar')".format(user=MySQLInstances().server_user))
status = self.proxy.group.remove("group", address_0)
self.check_xmlrpc_command_result(status, False)
status = self.proxy.group.add("group", address_0)
self.check_xmlrpc_command_result(status, has_error=True)
server_0.connect()
server_0.exec_stmt("SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('{passwd}')".format(
user=MySQLInstances().server_user,
passwd=MySQLInstances().server_passwd))
status = self.proxy.group.add("group", address_0)
self.check_xmlrpc_command_result(status, False)
#
# Revoke the REPLICATION SLAVE privilege from the server user,
# try a promote, which fails, grant REPLICATION SLAVE back.
#
server_0.exec_stmt(
"REVOKE REPLICATION SLAVE ON *.* FROM '{user}'@'%'".format(
user=MySQLInstances().server_user))
status = self.proxy.group.promote("group")
self.check_xmlrpc_command_result(status, has_error=True)
server_0.exec_stmt(
"GRANT REPLICATION SLAVE ON *.* TO '{user}'@'%'".format(
user=MySQLInstances().server_user))
#
# Do a successful promote.
#
status = self.proxy.group.promote("group")
self.check_xmlrpc_command_result(status, False)
def setUp(self):
"""Creates the following topology for testing,
GROUPID1 - localhost:13001, localhost:13002 - Global Group
GROUPID2 - localhost:13003, localhost:13004 - shard 1
GROUPID3 - localhost:13005, localhost:13006 - shard 2
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
self.__options_1 = {
"uuid": _uuid.UUID("{aa75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(0),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server1 = MySQLServer.discover_uuid(self.__options_1["address"])
self.__options_1["uuid"] = _uuid.UUID(uuid_server1)
self.__server_1 = MySQLServer(**self.__options_1)
MySQLServer.add(self.__server_1)
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(self.__server_1)
tests.utils.configure_decoupled_master(self.__group_1, self.__server_1)
self.__options_2 = {
"uuid": _uuid.UUID("{aa45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(1),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server2 = MySQLServer.discover_uuid(self.__options_2["address"])
self.__options_2["uuid"] = _uuid.UUID(uuid_server2)
self.__server_2 = MySQLServer(**self.__options_2)
MySQLServer.add(self.__server_2)
self.__server_2.connect()
self.__server_2.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_2.exec_stmt("CREATE DATABASE db1")
self.__server_2.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 71):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(101, 301):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(1001, 1201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(10001, 10201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(100001, 100201):
self.__server_2.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_2 = Group("GROUPID2", "Second description.")
Group.add(self.__group_2)
self.__group_2.add_server(self.__server_2)
tests.utils.configure_decoupled_master(self.__group_2, self.__server_2)
self.__options_3 = {
"uuid": _uuid.UUID("{bb75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(2),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server3 = MySQLServer.discover_uuid(self.__options_3["address"])
self.__options_3["uuid"] = _uuid.UUID(uuid_server3)
self.__server_3 = MySQLServer(**self.__options_3)
MySQLServer.add(self.__server_3)
self.__server_3.connect()
self.__server_3.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_3.exec_stmt("CREATE DATABASE db1")
self.__server_3.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 71):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(101, 301):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(1001, 1201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(10001, 10201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(100001, 100201):
self.__server_3.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_3 = Group("GROUPID3", "Third description.")
Group.add(self.__group_3)
self.__group_3.add_server(self.__server_3)
tests.utils.configure_decoupled_master(self.__group_3, self.__server_3)
self.__options_4 = {
"uuid": _uuid.UUID("{bb45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(3),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server4 = MySQLServer.discover_uuid(self.__options_4["address"])
self.__options_4["uuid"] = _uuid.UUID(uuid_server4)
self.__server_4 = MySQLServer(**self.__options_4)
MySQLServer.add(self.__server_4)
self.__server_4.connect()
self.__server_4.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_4.exec_stmt("CREATE DATABASE db1")
self.__server_4.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 71):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(101, 301):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(1001, 1201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(10001, 10201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(100001, 100201):
self.__server_4.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_4 = Group("GROUPID4", "Fourth description.")
Group.add(self.__group_4)
self.__group_4.add_server(self.__server_4)
tests.utils.configure_decoupled_master(self.__group_4, self.__server_4)
self.__options_5 = {
"uuid": _uuid.UUID("{cc75b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(4),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server5 = MySQLServer.discover_uuid(self.__options_5["address"])
self.__options_5["uuid"] = _uuid.UUID(uuid_server5)
self.__server_5 = MySQLServer(**self.__options_5)
MySQLServer.add(self.__server_5)
self.__server_5.connect()
self.__server_5.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_5.exec_stmt("CREATE DATABASE db1")
self.__server_5.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 71):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(101, 301):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(1001, 1201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(10001, 10201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(100001, 100201):
self.__server_5.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_5 = Group("GROUPID5", "Fifth description.")
Group.add(self.__group_5)
self.__group_5.add_server(self.__server_5)
tests.utils.configure_decoupled_master(self.__group_5, self.__server_5)
self.__options_6 = {
"uuid": _uuid.UUID("{cc45b12b-98d1-414c-96af-9e9d4b179678}"),
"address": MySQLInstances().get_address(5),
"user": MySQLInstances().user,
"passwd": MySQLInstances().passwd
}
uuid_server6 = MySQLServer.discover_uuid(self.__options_6["address"])
self.__options_6["uuid"] = _uuid.UUID(uuid_server6)
self.__server_6 = MySQLServer(**self.__options_6)
MySQLServer.add(self.__server_6)
self.__server_6.connect()
self.__server_6.exec_stmt("DROP DATABASE IF EXISTS db1")
self.__server_6.exec_stmt("CREATE DATABASE db1")
self.__server_6.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
for i in range(1, 71):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(101, 301):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(1001, 1201):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(10001, 10201):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
for i in range(100001, 100201):
self.__server_6.exec_stmt("INSERT INTO db1.t1 "
"VALUES(%s, 'TEST %s')" % (i, i))
self.__group_6 = Group("GROUPID6", "Sixth description.")
Group.add(self.__group_6)
self.__group_6.add_server(self.__server_6)
tests.utils.configure_decoupled_master(self.__group_6, self.__server_6)
status = self.proxy.sharding.create_definition("RANGE", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(
1, "GROUPID2/1,GROUPID3/101,GROUPID4/1001,"
"GROUPID5/10001,GROUPID6/100001", "ENABLED")
self.check_xmlrpc_command_result(status)
def test_clone_permissions(self):
"""Verify the permissions, needed for a clone operation.
Change password of the backup user, clone fails on backup.
Change password back,
Revoke SELECT from the backup user, clone fails on backup.
Grant SELECT back,
Change password of the restore user, clone fails on restore.
Change password back,
Revoke CREATE from the restore user, clone fails on restore.
Grant CREATE back.
Clone succeeds.
"""
#
# Skip test in trial-mode. Users are the same as admin user.
# Admin won't be able to grant a privilege back to itself.
#
if ((MySQLInstances().backup_user == MySQLInstances().user)
or (MySQLInstances().restore_user == MySQLInstances().user)):
# The trailing comma prevents a newline.
print "Skipping test_clone_permissions in trial-mode --- ",
return
server1 = self.__server_1
server2 = self.__server_2
server3 = self.__server_3
#
# Construct a group in the backing store.
#
self.__group_1 = Group("GROUPID1", "First description.")
Group.add(self.__group_1)
self.__group_1.add_server(server1)
self.__group_1.add_server(server2)
self.__group_1.master = server2.uuid
#
# Change password of the the backup user, try a clone, which
# fails, because the Fabric instance does still use the old
# password, change password back. This works, because Fabric
# does not pool the connections for backup and restore users. So
# they have to be freshly connected for backup and restore
# operations.
#
server1.exec_stmt(
"SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('foobar')".format(user=MySQLInstances().backup_user))
status = self.proxy.server.clone("GROUPID1", server3.address, None)
self.check_xmlrpc_command_result(status, has_error=True)
server1.exec_stmt("SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('{passwd}')".format(
user=MySQLInstances().backup_user,
passwd=MySQLInstances().backup_passwd))
#
# Revoke the SELECT privilege from the backup user,
# try a clone, which fails, grant SELECT back.
#
server1.exec_stmt("REVOKE SELECT ON *.* FROM '{user}'@'%'".format(
user=MySQLInstances().backup_user))
status = self.proxy.server.clone("GROUPID1", server3.address, None)
self.check_xmlrpc_command_result(status, has_error=True)
server1.exec_stmt("GRANT SELECT ON *.* TO '{user}'@'%'".format(
user=MySQLInstances().backup_user))
#
# Change password of the the restore user, try a clone, which
# fails, because the Fabric instance does still use the old
# password, change password back. This works, because Fabric
# does not pool the connections for backup and restore users. So
# they have to be freshly connected for backup and restore
# operations.
#
server3.exec_stmt(
"SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('foobar')".format(user=MySQLInstances().restore_user))
status = self.proxy.server.clone("GROUPID1", server3.address, None)
self.check_xmlrpc_command_result(status, has_error=True)
server3.exec_stmt("SET PASSWORD FOR '{user}'@'%' ="
" PASSWORD('{passwd}')".format(
user=MySQLInstances().restore_user,
passwd=MySQLInstances().restore_passwd))
#
# Revoke the CREATE privilege from the restore user,
# try a clone, which fails, grant CREATE back.
#
server3.exec_stmt("REVOKE CREATE ON *.* FROM '{user}'@'%'".format(
user=MySQLInstances().restore_user))
# We have to clear GTID_EXECUTED before we can restore.
reset_master(server3)
status = self.proxy.server.clone("GROUPID1", server3.address, None)
self.check_xmlrpc_command_result(status, has_error=True)
server3.exec_stmt("GRANT CREATE ON *.* TO '{user}'@'%'".format(
user=MySQLInstances().restore_user))
# We have to clear GTID_EXECUTED before we can try the next restore.
reset_master(server3)
#
# Run a successful clone.
#
status = self.proxy.server.clone("GROUPID1", server3.address, None)
self.check_xmlrpc_command_result(status)
rows = server3.exec_stmt("SELECT NAME FROM db1.t1", {"fetch": True})
self.assertEqual(len(rows), 2)
self.assertEqual(rows[0][0], 'TEST 1')
self.assertEqual(rows[1][0], 'TEST 2')
rows = server3.exec_stmt("SELECT NAME FROM db2.t1", {"fetch": True})
self.assertEqual(len(rows), 2)
self.assertEqual(rows[0][0], 'TEST 1')
self.assertEqual(rows[1][0], 'TEST 2')
def setUp(self):
"""Creates the following topology for testing,
GROUPID1 - localhost:13001, localhost:13002 - Global Group
GROUPID2 - localhost:13003, localhost:13004 - shard 1
GROUPID3 - localhost:13005, localhost:13006 - shard 2
"""
self.manager, self.proxy = tests.utils.setup_xmlrpc()
status = self.proxy.group.create("GROUPID1", "First description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID1",
MySQLInstances().get_address(0))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID1",
MySQLInstances().get_address(1))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.create("GROUPID2", "Second description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID2",
MySQLInstances().get_address(2))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID2",
MySQLInstances().get_address(3))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.create("GROUPID3", "Third description.")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID3",
MySQLInstances().get_address(4))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.add("GROUPID3",
MySQLInstances().get_address(5))
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID1")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID2")
self.check_xmlrpc_command_result(status)
status = self.proxy.group.promote("GROUPID3")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.create_definition("RANGE", "GROUPID1")
self.check_xmlrpc_command_result(status, returns=1)
status = self.proxy.sharding.add_table(1, "db1.t1", "userID")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.add_shard(1, "GROUPID2/0", "ENABLED")
self.check_xmlrpc_command_result(status)
status = self.proxy.sharding.lookup_servers("db1.t1", 500, "LOCAL")
for row in self.check_xmlrpc_iter(status):
if row['status'] == MySQLServer.PRIMARY:
shard_server = fetch_test_server(row['server_uuid'])
shard_server.connect()
shard_server.exec_stmt("DROP DATABASE IF EXISTS db1")
shard_server.exec_stmt("CREATE DATABASE db1")
shard_server.exec_stmt("CREATE TABLE db1.t1"
"(userID INT, name VARCHAR(30))")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(101, 'TEST 1')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(102, 'TEST 2')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(103, 'TEST 3')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(1001, 'TEST 4')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(1002, 'TEST 5')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(1003, 'TEST 6')")
shard_server.exec_stmt("INSERT INTO db1.t1 " "VALUES(1004, 'TEST 7')")
def test_lookup(self):
expected_uuid_list = [
str(self.__server_3.uuid),
str(self.__server_4.uuid)
]
expected_address_list = [
MySQLInstances().get_address(2),
MySQLInstances().get_address(3)
]
# Lookup any key
obtained_uuid_list = []
obtained_address_list = []
status = self.proxy.sharding.lookup_servers("db1.t1", 500, "LOCAL")
for row in self.check_xmlrpc_iter(status):
obtained_uuid_list.append(row['server_uuid'])
obtained_address_list.append(row['address'])
self.assertEqual(set(expected_uuid_list), set(obtained_uuid_list))
self.assertEqual(set(expected_address_list),
set(obtained_address_list))
# Lookup first key
obtained_uuid_list = []
obtained_address_list = []
status = self.proxy.sharding.lookup_servers("db1.t1", 1, "LOCAL")
for row in self.check_xmlrpc_iter(status):
obtained_uuid_list.append(row['server_uuid'])
obtained_address_list.append(row['address'])
self.assertEqual(set(expected_uuid_list), set(obtained_uuid_list))
self.assertEqual(set(expected_address_list),
set(obtained_address_list))
# Lookup last key
obtained_uuid_list = []
obtained_address_list = []
status = self.proxy.sharding.lookup_servers("db1.t1", 1000, "LOCAL")
for row in self.check_xmlrpc_iter(status):
obtained_uuid_list.append(row['server_uuid'])
obtained_address_list.append(row['address'])
self.assertEqual(set(expected_uuid_list), set(obtained_uuid_list))
self.assertEqual(set(expected_address_list),
set(obtained_address_list))
# Lookup first in next key.
expected_uuid_list = [
str(self.__server_5.uuid),
str(self.__server_6.uuid)
]
expected_address_list = [
MySQLInstances().get_address(4),
MySQLInstances().get_address(5)
]
obtained_uuid_list = []
obtained_address_list = []
status = self.proxy.sharding.lookup_servers("db1.t1", 1001, "LOCAL")
for row in self.check_xmlrpc_iter(status):
obtained_uuid_list.append(row['server_uuid'])
obtained_address_list.append(row['address'])
self.assertEqual(set(expected_uuid_list), set(obtained_uuid_list))
self.assertEqual(set(expected_address_list),
set(obtained_address_list))
# Lookup wrong table
status = self.proxy.sharding.lookup_servers("Wrong", 500, "LOCAL")
self.check_xmlrpc_command_result(status, has_error=True)
# Lookup wrong key
status = self.proxy.sharding.lookup_servers("db1.t1", 55500, "LOCAL")
for row in self.check_xmlrpc_iter(status):
obtained_uuid_list.append(row['server_uuid'])
obtained_address_list.append(row['address'])
self.assertEqual(set(expected_uuid_list), set(obtained_uuid_list))
self.assertEqual(set(expected_address_list),
set(obtained_address_list))