def _create_flavors(self, client, ram, disk, vcpus=1):
name = rand_name('ost1_test-flavor-')
flavorid = rand_int_id()
exist_ids = [flavor.id for flavor
in self.compute_client.flavors.list()]
if flavorid in exist_ids:
flavorid = name + rand_int_id()
flavor = client.flavors.create(name=name, ram=ram, disk=disk,
vcpus=vcpus, flavorid=flavorid)
self.created_flavors.append(flavor)
return flavor
def _create_flavors(self, client, ram, disk, vcpus=1):
name = rand_name('ost1_test-flavor-')
flavorid = rand_int_id()
flavor = client.flavors.create(name=name, ram=ram, disk=disk,
vcpus=vcpus, flavorid=flavorid)
self.flavors.append(flavor)
return flavor
def setUpClass(cls):
super(TestMysqlReplication, cls).setUpClass()
cls.controller_ip = cls.config.compute.online_controllers[0]
cls.controllers = cls.config.compute.online_controllers
cls.controller_key = cls.config.compute.path_to_private_key
cls.controller_user = cls.config.compute.ssh_user
cls.mysql_user = '******'
cls.database = 'ost1' + str(data_utils.rand_int_id(100, 999))
cls.master_ip = []
def setUpClass(cls):
super(TestMysqlReplication, cls).setUpClass()
cls.controller_ip = cls.config.compute.online_controllers[0]
cls.controllers = cls.config.compute.online_controllers
cls.controller_key = cls.config.compute.path_to_private_key
cls.controller_user = cls.config.compute.ssh_user
cls.mysql_user = '******'
cls.database = 'ost1' + str(data_utils.rand_int_id(100, 999))
cls.master_ip = []
def _create_nano_flavor(cls):
name = rand_name('ost1_test-flavor-nano')
flavorid = rand_int_id(999, 10000)
try:
flavor = cls.compute_client.flavors.create(
name, 64, 1, 1, flavorid)
except Exception:
LOG.debug("OSTF test flavor cannot be created.")
LOG.debug(traceback.format_exc())
return flavor
def _create_flavors(self, client, ram, disk, vcpus=1):
name = rand_name('ost1_test-flavor-')
flavorid = rand_int_id()
flavor = client.flavors.create(name=name,
ram=ram,
disk=disk,
vcpus=vcpus,
flavorid=flavorid)
self.flavors.append(flavor)
return flavor
def _create_nano_flavor(cls):
name = rand_name('ost1_test-flavor-nano')
flavorid = rand_int_id(999, 10000)
flavor = None
try:
flavor = cls.compute_client.flavors.create(name, 64, 1, 1,
flavorid)
except Exception:
LOG.debug("OSTF test flavor cannot be created.")
LOG.debug(traceback.format_exc())
return flavor
def test_mysql_replication(self):
"""Check data replication over mysql
Target Service: HA mysql
Scenario:
1. Check that mysql is running on all controller or database nodes.
2. Create database on one node.
3. Create table in created database
4. Insert data to the created table
5. Get replicated data from each database node.
6. Verify that replicated data in the same from each database
7. Drop created database
Duration: 10 s.
"""
LOG.info("'Test MySQL replication' started")
databases = self.verify(20,
self.get_database_nodes,
1, "Can not get database hostnames. Check that"
" at least one controller is operable",
"get database nodes",
self.controller_ip,
self.node_user,
key=self.node_key)
self.verify_response_body_not_equal(0, len(databases), self.no_db_msg,
1)
if len(databases) == 1:
self.skipTest(self.one_db_msg)
LOG.info("Database nodes are " + ", ".join(databases))
self.master_ip = databases[0]
# check that mysql is running on all hosts
cmd = 'mysql -h localhost -e "" '
for db_node in databases:
ssh_client = ssh.Client(db_node,
self.node_user,
key_filename=self.node_key,
timeout=100)
self.verify(
20, ssh_client.exec_command, 1, 'Can not connect to mysql. '
'Please check that mysql is running and there '
'is connectivity by management network', 'detect mysql node',
cmd)
database_name = self.database
table_name = 'ost' + str(data_utils.rand_int_id(100, 999))
record_data = str(data_utils.rand_int_id(1000000000, 9999999999))
create_database = (
'mysql -h localhost -e "CREATE DATABASE IF NOT EXISTS '
'{database}" '.format(database=database_name))
create_table = ('mysql -h localhost -e'
' "CREATE TABLE IF NOT EXISTS {database}.{table}'
' (data VARCHAR(100))" '.format(database=database_name,
table=table_name))
create_record = (
'mysql -h localhost -e "INSERT INTO {database}.{table} (data) '
'VALUES({data})" '.format(database=database_name,
table=table_name,
data=record_data))
get_record = (
'mysql -h localhost -e "SELECT * FROM {database}.{table} '
'WHERE data = \"{data}\"" '.format(database=database_name,
table=table_name,
data=record_data))
drop_db = "mysql -h localhost -e 'DROP DATABASE {database}'".format(
database=database_name)
# create db, table, insert data on one node
LOG.info('target node ip/hostname: "{0}" '.format(self.master_ip))
master_ssh_client = ssh.Client(self.master_ip,
self.node_user,
key_filename=self.node_key,
timeout=100)
self.verify(20, master_ssh_client.exec_command, 2,
'Database creation failed', 'create database',
create_database)
LOG.info('create database')
self.verify(20, master_ssh_client.exec_command, 3,
'Table creation failed', 'create table', create_table)
LOG.info('create table')
self.verify(20, master_ssh_client.exec_command, 4,
'Can not insert data in created table', 'data insertion',
create_record)
LOG.info('create data')
# Verify that data is replicated on other databases
for db_node in databases:
if db_node != self.master_ip:
client = ssh.Client(db_node,
self.node_user,
key_filename=self.node_key)
output = self.verify(
20, client.exec_command, 5,
'Can not get data from database node %s' % db_node,
'get_record', get_record)
self.verify_response_body(output,
record_data,
msg='Expected data missing',
failed_step='6')
# Drop created db
ssh_client = ssh.Client(self.master_ip,
self.node_user,
key_filename=self.node_key)
self.verify(20, ssh_client.exec_command, 7,
'Can not delete created database', 'database deletion',
drop_db)
self.master_ip = None
def setUpClass(cls):
super(TestMysqlReplication, cls).setUpClass()
cls.database = 'ost1' + str(data_utils.rand_int_id(100, 999))
cls.master_ip = None
def test_mysql_replication(self):
"""Check data replication over mysql
Target Service: HA mysql
Scenario:
1. Check that mysql is running on all controller or database nodes.
2. Create database on one node.
3. Create table in created database
4. Insert data to the created table
5. Get replicated data from each database node.
6. Verify that replicated data in the same from each database
7. Drop created database
Duration: 10 s.
"""
LOG.info("'Test MySQL replication' started")
databases = self.verify(20, self.get_database_nodes,
1, "Can not get database hostnames. Check that"
" at least one controller is operable",
"get database nodes",
self.controller_ip,
self.node_user,
key=self.node_key)
if len(databases) == 1:
self.skipTest('There is only one database online. '
'Nothing to check')
LOG.info("Database nodes are " + ", ".join(databases))
self.master_ip = databases[0]
# check that mysql is running on all hosts
cmd = 'mysql -h localhost -e "" '
for db_node in databases:
ssh_client = SSHClient(
db_node, self.node_user,
key_filename=self.node_key, timeout=100)
self.verify(
20, ssh_client.exec_command, 1,
'Can not connect to mysql. '
'Please check that mysql is running and there '
'is connectivity by management network',
'detect mysql node', cmd)
database_name = self.database
table_name = 'ost' + str(data_utils.rand_int_id(100, 999))
record_data = str(data_utils.rand_int_id(1000000000, 9999999999))
create_database = (
'mysql -h localhost -e "CREATE DATABASE IF NOT EXISTS '
'{database}" '.format(database=database_name)
)
create_table = (
'mysql -h localhost -e'
' "CREATE TABLE IF NOT EXISTS {database}.{table}'
' (data VARCHAR(100))" '.format(database=database_name,
table=table_name)
)
create_record = (
'mysql -h localhost -e "INSERT INTO {database}.{table} (data) '
'VALUES({data})" '.format(database=database_name,
table=table_name,
data=record_data)
)
get_record = (
'mysql -h localhost -e "SELECT * FROM {database}.{table} '
'WHERE data = \"{data}\"" '.format(database=database_name,
table=table_name,
data=record_data)
)
drop_db = "mysql -h localhost -e 'DROP DATABASE {database}'".format(
database=database_name
)
# create db, table, insert data on one node
LOG.info('target node ip/hostname: "{0}" '.format(self.master_ip))
master_ssh_client = SSHClient(self.master_ip, self.node_user,
key_filename=self.node_key,
timeout=100)
self.verify(20, master_ssh_client.exec_command, 2,
'Database creation failed', 'create database',
create_database)
LOG.info('create database')
self.verify(20, master_ssh_client.exec_command, 3,
'Table creation failed', 'create table', create_table)
LOG.info('create table')
self.verify(20, master_ssh_client.exec_command, 4,
'Can not insert data in created table', 'data insertion',
create_record)
LOG.info('create data')
# Verify that data is replicated on other databases
for db_node in databases:
if db_node != self.master_ip:
client = SSHClient(db_node,
self.node_user,
key_filename=self.node_key)
output = self.verify(
20, client.exec_command, 5,
'Can not get data from database node %s' % db_node,
'get_record', get_record)
self.verify_response_body(output, record_data,
msg='Expected data missing',
failed_step='6')
# Drop created db
ssh_client = SSHClient(self.master_ip, self.node_user,
key_filename=self.node_key)
self.verify(20, ssh_client.exec_command, 7,
'Can not delete created database',
'database deletion', drop_db)
self.master_ip = None
def setUpClass(cls):
super(TestMysqlReplication, cls).setUpClass()
cls.database = 'ost1' + str(data_utils.rand_int_id(100, 999))
cls.master_ip = None
def test_mysql_replication(self):
"""Check data replication over mysql
Target Service: HA mysql
Scenario:
1. Detect mysql node.
2. Create database on detected node
3. Create table in created database
4. Insert data to the created table
5. Get replicated data from each controller.
6. Verify that replicated data in the same from each controller
7. Drop created database
Duration: 100 s.
"""
# Find mysql master node
master_node_ip = []
cmd = 'mysql -e "SHOW SLAVE STATUS\G"'
LOG.info("Controllers nodes are %s" % self.controllers)
for controller_ip in self.controllers:
ssh_client = SSHClient(controller_ip,
self.controller_user,
key_filename=self.controller_key,
timeout=100)
output = self.verify(20, ssh_client.exec_command, 1,
'Mysql node detection failed',
'detect mysql node', cmd)
LOG.info('output is %s' % output)
if not output:
self.master_ip.append(controller_ip)
master_node_ip.append(controller_ip)
database_name = self.database
table_name = 'ost' + str(data_utils.rand_int_id(100, 999))
record_data = str(data_utils.rand_int_id(1000000000, 9999999999))
create_database = 'mysql -e "CREATE DATABASE IF NOT EXISTS %s"'\
% database_name
create_table = 'mysql -e "CREATE TABLE IF NOT EXISTS'\
' %(database)s.%(table)s'\
' (data VARCHAR(100))"'\
% {'database': database_name,
'table': table_name}
create_record = 'mysql -e "INSERT INTO %(database)s.%(table)s (data)'\
' VALUES(%(data)s)"'\
% {'database': database_name,
'table': table_name,
'data': record_data}
get_record = 'mysql -e "SELECT * FROM %(database)s.%(table)s '\
'WHERE data = \"%(data)s\""'\
% {'database': database_name,
'table': table_name,
'data': record_data}
# create db, table, insert data on master
LOG.info('master node ip %s' % master_node_ip[0])
master_ssh_client = SSHClient(master_node_ip[0],
self.controller_user,
key_filename=self.controller_key,
timeout=100)
self.verify(20, master_ssh_client.exec_command, 2,
'Database creation failed', 'create database',
create_database)
LOG.info('create database')
self.verify(20, master_ssh_client.exec_command, 3,
'Table creation failed', 'create table', create_table)
LOG.info('create table')
self.verify(20, master_ssh_client.exec_command, 4,
'Can not insert data in created table', 'data insertion',
create_record)
LOG.info('create data')
# Verify that data is replicated on other controllers
for controller in self.controllers:
if controller not in master_node_ip:
client = SSHClient(controller,
self.controller_user,
key_filename=self.controller_key)
output = self.verify(
20, client.exec_command, 5,
'Can not get data from controller %s' % controller,
'get_record', get_record)
self.verify_response_body(output,
record_data,
msg='Expected data missing',
failed_step='6')
# Drop created db
cmd = "mysql -e 'DROP DATABASE %s'" % self.database
ssh_client = SSHClient(master_node_ip[0],
self.controller_user,
key_filename=self.controller_key)
self.verify(20, ssh_client.exec_command, 7,
'Can not delete created database', 'database deletion',
cmd)
self.master_ip = []
def test_mysql_replication(self):
"""Check data replication over mysql
Target Service: HA mysql
Scenario:
1. Detect mysql node.
2. Create database on detected node
3. Create table in created database
4. Insert data to the created table
5. Get replicated data from each controller.
6. Verify that replicated data in the same from each controller
7. Drop created database
Duration: 100 s.
"""
# Find mysql master node
master_node_ip = []
cmd = 'mysql -e "SHOW SLAVE STATUS\G"'
LOG.info("Controllers nodes are %s" % self.controllers)
for controller_ip in self.controllers:
ssh_client = SSHClient(
controller_ip, self.controller_user,
key_filename=self.controller_key, timeout=100)
output = self.verify(
20, ssh_client.exec_command, 1,
'Can not connect to mysql. '
'Please check that mysql is running and there '
'is connectivity by management network',
'detect mysql node', cmd)
LOG.info('output is %s' % output)
if not output:
self.master_ip.append(controller_ip)
master_node_ip.append(controller_ip)
database_name = self.database
table_name = 'ost' + str(data_utils.rand_int_id(100, 999))
record_data = str(data_utils.rand_int_id(1000000000, 9999999999))
create_database = 'mysql -e "CREATE DATABASE IF NOT EXISTS %s"'\
% database_name
create_table = 'mysql -e "CREATE TABLE IF NOT EXISTS'\
' %(database)s.%(table)s'\
' (data VARCHAR(100))"'\
% {'database': database_name,
'table': table_name}
create_record = 'mysql -e "INSERT INTO %(database)s.%(table)s (data)'\
' VALUES(%(data)s)"'\
% {'database': database_name,
'table': table_name,
'data': record_data}
get_record = 'mysql -e "SELECT * FROM %(database)s.%(table)s '\
'WHERE data = \"%(data)s\""'\
% {'database': database_name,
'table': table_name,
'data': record_data}
# create db, table, insert data on master
LOG.info('master node ip %s' % master_node_ip[0])
master_ssh_client = SSHClient(master_node_ip[0], self.controller_user,
key_filename=self.controller_key,
timeout=100)
self.verify(20, master_ssh_client.exec_command, 2,
'Database creation failed', 'create database',
create_database)
LOG.info('create database')
self.verify(20, master_ssh_client.exec_command, 3,
'Table creation failed', 'create table', create_table)
LOG.info('create table')
self.verify(20, master_ssh_client.exec_command, 4,
'Can not insert data in created table', 'data insertion',
create_record)
LOG.info('create data')
# Verify that data is replicated on other controllers
for controller in self.controllers:
if controller not in master_node_ip:
client = SSHClient(controller,
self.controller_user,
key_filename=self.controller_key)
output = self.verify(
20, client.exec_command, 5,
'Can not get data from controller %s' % controller,
'get_record', get_record)
self.verify_response_body(output, record_data,
msg='Expected data missing',
failed_step='6')
# Drop created db
cmd = "mysql -e 'DROP DATABASE %s'" % self.database
ssh_client = SSHClient(master_node_ip[0], self.controller_user,
key_filename=self.controller_key)
self.verify(20, ssh_client.exec_command, 7,
'Can not delete created database',
'database deletion', cmd)
self.master_ip = []
