def _update_pool(self, pool_id, size, group_id, pg_num):
"""
Execute the test of updating a pool
"""
# sleep 60s, otherwise it may raise error about "the pool is not ready"
pool_name = 'cloudtest_' + utils.utils_misc.generate_random_string(6)
vgroup_id = test_utils.get_available_vgroup(self.params)
if self.params.get('NO_EC', "true") == "true":
update_pool = {
'name': pool_name,
'size': size,
'group_id': group_id,
'pg_num': pg_num,
'vgroup_id': vgroup_id
}
else:
update_pool = {
'name': pool_name,
'group_id': self.params.get('rest_arg_group_id', 1),
'pg_num': self.params.get('rest_arg_pg_num', 80),
'vgroup_id': vgroup_id,
'safe_type': self.params.get('safe_type', 10),
'data_block_num': self.params.get('data_block_num', 3),
'code_block_num': self.params.get('code_block_num', 0),
'min_size': self.params.get('min_size', 1),
'max_bytes': self.params.get("max_bytes", 1073741824)
}
resp = self.pool_client.update(pool_id, **update_pool)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Update pool failed: %s" % self.body)
time.sleep(240)
def test_create_regular_export_job(self):
"""
Test create job for regular export logs to remote
"""
ceph_server_ip = self.params.get('ceph_management_url')
controller_ip = test_utils.get_ip_from_string(ceph_server_ip)
controller_username = self.params.get('ceph_server_ssh_username')
controller_password = self.params.get('ceph_server_ssh_password')
regular_export = {
'interval': 1,
'interval_unit': 'minute',
'server_ip': controller_ip,
'server_password': controller_password,
'server_path': '/tmp',
'server_port': 22,
'server_username': controller_username,
'type': 'operation'
}
resp = self.client.regular_export(**regular_export)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create regular export to remote job "
"failed: %s" % self.body)
def test_update(self):
"""
Execute the test of updating a pool
"""
pool_id = self.env.get('pool_tmp_id')
pool_name = 'cloudtest_' + utils_misc.generate_random_string(6)
if self.params.get('NO_EC', "true") == "true":
update_pool = {
'name': pool_name,
'size': self.params.get('rest_arg_size', 3),
'group_id': self.params.get('rest_arg_group_id', 1),
'pg_num': self.params.get('rest_arg_pg_num', 600),
'vgroup_id': self.env.get('vgroup_id', 1)
}
else:
update_pool = {
'name': pool_name,
'group_id': self.params.get('rest_arg_group_id', 1),
'pg_num': self.params.get('rest_arg_pg_num', 448),
'vgroup_id': self.env.get('vgroup_id', 1),
'safe_type': self.params.get('safe_type', 0),
'data_block_num': self.params.get('data_block_num', 3),
'code_block_num': self.params.get('code_block_num', 0),
'min_size': self.params.get('min_size', 1),
'max_bytes': self.params.get("max_bytes", 1073741824),
'write_mode': self.params.get("write_mode", "writeback"),
}
resp = self.client.update(pool_id, **update_pool)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Update pool failed: %s" % self.body)
def test_set_ec_pool_cache(self):
"""
Set up cache for EC pool
"""
pool_id = self.env.get('pool_tmp_id')
vgroup_id = self.env.get('vgroup_id', 1)
cache_pool = test_utils.create_pool(self.params,
flag=True,
vgroup_id=vgroup_id)
self.env['cache_pool_id'] = cache_pool.get('pool_id')
self.env['cache_pool_name'] = cache_pool.get('name')
if self.params.get('NO_EC', "true") == "true":
raise exceptions.TestSkipError("There is not EC pool")
else:
set_cache = {
'cache_pool_id': cache_pool.get('pool_id'),
'cache_pool_name': cache_pool.get('name'),
'cache_size': 107374182400,
'target_dirty_radio': 30,
'target_full_radio': 70,
'option': 'set_cache',
'caching_mode': 'writeback',
}
resp = self.client.set_cache(pool_id, **set_cache)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Set up EC pool cache failed: %s" %
self.body)
def test_create(self):
"""
Execute the test of creating a Server
"""
# if there is not enough resource to create server, skip it
if not (self.body.get('servername') and self.body.get('publicip')
and self.body.get('clusterip') and self.body.get('username')
and self.body.get('password')):
raise exceptions.TestSkipError("There is not enough resource"
" to create server!")
if not self.body.get('parent_bucket'):
group_id, parent_id = \
test_utils.get_available_group_bucket(self.params)
self.body.update({'parent_bucket': parent_id})
resp_body = self.client.create(**self.body)
body = resp_body.body
if not resp_body and utils.verify_response(self.body, resp_body):
raise exceptions.TestFail("Create server failed: %s" % self.body)
status = test_utils.wait_for_server_in_status(
'servername', self.body['servername'], self.client, 'added', 1,
int(self.params.get('add_host_timeout', 600)))
if not status:
raise exceptions.TestFail("Failed to add server %s" %
self.body['servername'])
LOG.info('Create server %s successfully!' %
body['properties'].get('name'))
self.env['server_name'] = body['properties'].get('name')
self._query_servers()
def _set_cluster_conf(self):
resp = self.clusterconf_client.set(self.cluster_id, self.body)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Set cluster conf failed: %s" %
self.body)
LOG.info("Set cluster conf: %s" % self.body)
time.sleep(30)
def test_update(self):
"""
Execute the test of update qos
"""
self.client.disable()
resp = self.client.update(**self.body)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Update qos failed: %s" % self.body)
def test_set(self):
"""
Execute the test of set cluster conf
"""
resp = self.client.set(self.cluster_id, self.body)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Set cluster conf failed: %s" %
self.body)
def _create_cluster(self):
create_cluster = {'name': self.params.get('cluster_name',
'cloudtest_cluster_2'),
'addr': self.params.get('cluster_addr', 'vm')}
resp = self.clusters_client.create(**create_cluster)
if not resp and utils.verify_response(create_cluster, resp):
raise exceptions.TestSetupFail(
"Create cluster failed: %s" % create_cluster)
return resp.body.get('id')
def _migrate_rbd(self, src_pool_id, des_pool_id, rbd_id, rbd_name):
LOG.info("Try to migrate rbd %s" % rbd_name)
move_rbd = {'target_pool': des_pool_id}
resp = self.rbd_client.migrate(src_pool_id, rbd_id, **move_rbd)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Migrate rbd failed: %s" % self.body)
status = self._wait_for_rbd_in_status(des_pool_id, rbd_name, 'ready')
if not status:
raise exceptions.TestFail('Failed to migrate rbd %s!' % rbd_name)
LOG.info('Migrate rbd %s successfully !' % rbd_name)
def test_copy(self):
"""
Test copy rbd
"""
rbd_id = self.env.get('rbd_tmp_id')
copy_rbd = {'target_pool': self.pool_id}
resp = self.client.copy_rbd(self.pool_id, rbd_id, **copy_rbd)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Copy rbd failed: %s" % self.body)
def _create_iscsi_target(self):
self.iscsi_target_name = "cloudtest" + \
utils.utils_misc.generate_random_string(6)
create_body = {'initiator_ips': self.initiator_ip,
'target_name': self.iscsi_target_name,
'multipath': self.params.get('multipath', 3)}
resp = self.iscsi_client.create(**create_body)
if not resp and utils.verify_response(create_body, resp):
raise exceptions.TestFail("Create target failed: %s "
% create_body)
return resp.body['target_id']
def _modify_account_group(self, account_id, account_name, account_pass,
account_name_out, account_pass_out):
"""
Modify account group
"""
resp = self.iscsi_client.modify_account_group(account_id, account_name,
account_pass,
account_name_out,
account_pass_out)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Modify account group failed: %s" %
self.body)
def test_create_account_group(self):
"""
Execute the test of creating account group
"""
account_name = utils.utils_misc.generate_random_string(6)
account_pass = utils.utils_misc.generate_random_string(12)
gateway_id = self.gateway_id
resp = self.client.create_account_group(account_name, account_pass,
"single", str(gateway_id))
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create account group failed: %s")
self.env['iscsi_accountgroup'] = resp.body
def test_modify_account_group(self):
"""
Modify account group
"""
account_id = self.env.get('iscsi_accountgroup')['group_id']
account_name = utils.utils_misc.generate_random_string(6)
account_pass = utils.utils_misc.generate_random_string(6)
resp = self.client.modify_account_group(account_id, account_name,
account_pass)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Modify account group failed: %s" %
self.body)
def test_modify_iscsi(self):
"""
Modify iscsi targets's initiator ip
"""
target_id = self.env.get('iscsi_target')['target_id']
modify_iscsi = {
'initiator_ips': "192.168.1.34",
'old_initiator_ip': "192.168.1.30"
}
resp = self.client.modify_iscsi(target_id, **modify_iscsi)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail(
"Modify iscsi target export host failed: %s" % self.body)
def test_migrate(self):
"""
Test that migration of specified rdb
"""
rbd_id = self.env.get('rbd_tmp_id')
vgroup_id = self.env.get('vgroup_id')
target_pool = test_utils.create_pool(self.params, vgroup_id=vgroup_id)
time.sleep(60)
move_rbd = {'target_pool': str(target_pool)}
resp = self.client.migrate(self.pool_id, rbd_id, **move_rbd)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Migarate rbd failed: %s" % self.body)
self.env['pool_target_id'] = target_pool
def test_create(self):
"""
Execute the test of creating a cluster
"""
try:
resp = self.client.create(**self.body)
except:
if len(self.body['name']) > 32:
LOG.warn('Known bug, cluster name should not exceed 32 chars')
return
else:
raise
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create cluster failed: %s" % self.body)
cluster_id = resp.body.get('id')
if self.params.get('resource_need_delete', 'no') in 'yes':
self.resource_to_delete.append(cluster_id)
def test_create(self):
"""
Execute the test of creating a rbd
"""
rbd_name = self.params.get(
'rbd_name', 'cloudtest_' + utils_misc.generate_random_string(6))
create_rbd = {
'name': rbd_name,
'object_size': self.params.get('object_size', 0),
'capacity': self.params.get('capacity', 200),
'num': self.params.get('num', 1),
'shared': self.params.get('shared', 0)
}
resp = self.client.create(self.pool_id, **create_rbd)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create rbd failed: %s" % self.body)
self.env['rbd_tmp_name'] = rbd_name
test_utils.wait_for_rbd_create(self.client, self.pool_id, rbd_name)
def _create_account_group(self, account_type):
"""
Execute the test of creating account group
"""
account_name = data_factory.generate_random_string(6)
account_pass = data_factory.generate_random_string(12)
account_out_name = data_factory.generate_random_string(6)
account_out_pass = data_factory.generate_random_string(12)
resp = self.iscsi_client.create_account_group(account_name,
account_pass,
account_type,
account_out_name,
account_out_pass)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create account group failed: %s")
return resp['group_id']
def test_update(self):
"""
Execute the test of updating a rbd
"""
rbd_id = self.env.get('rbd_tmp_id')
# rbd_id = 11
rbd_name = 'cloudtest_' + utils_misc.generate_random_string(6)
update_rbd = {
'name': rbd_name,
'object_size': self.params.get('rest_arg_object_size', 1),
'capacity': self.params.get('rest_arg_capacity', 200)
}
resp = self.client.update(self.pool_id, rbd_id, **update_rbd)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Update rbd failed: %s" % self.body)
else:
self.env['rbd_tmp_name'] = rbd_name
def setup(self):
LOG.info("Try to create cluster cloudtest_cluster")
create_cluster = {
'name': self.params.get('cluster_name', 'cloudtest_cluster'),
'addr': self.params.get('cluster_addr', 'vm')
}
resp = self.clusters_client.create(**create_cluster)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestSetupFail("Create cluster failed: %s" %
self.body)
self.cluster_id = resp.body.get('id')
self.params['cluster_id'] = self.cluster_id
self.groups_client = GroupsClient(self.params)
self.servers_client = ServersClient(self.params)
for k, v in self.params.items():
if 'rest_arg_' in k:
new_key = k.split('rest_arg_')[1]
self.body[new_key] = v
def test_unset_ec_pool_cache(self):
"""
Unset cache for EC pool
"""
pool_id = self.env.get('pool_tmp_id')
if self.params.get('NO_EC', "true") == "true":
raise exceptions.TestSkipError("There is not EC pool")
else:
unset_cache = {
'cache_pool_id': self.env['cache_pool_id'],
'cache_pool_name': self.env['cache_pool_name'],
'option': 'unset_cache',
}
resp = self.client.unset_cache(pool_id, **unset_cache)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Unset up EC pool cache failed: %s" %
self.body)
def setup(self):
"""
Set up before executing test
"""
LOG.info("Try to create cluster cloudtest_cluster")
create_cluster = {
'name': self.params.get('cluster_name', 'cloudtest_cluster'),
'addr': self.params.get('cluster_addr', 'vm')
}
resp = self.clusters_client.create(**create_cluster)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestSetupFail("Create cluster failed: %s" %
self.body)
self.cluster_id = resp.body.get('id')
LOG.info("Created cluster successfully!")
self.params['cluster_id'] = self.cluster_id
self.servers_client = ServersClient(self.params)
self.group_client = GroupsClient(self.params)
self.pool_client = PoolsClient(self.params)
self.rbd_client = RbdClient(self.params)
self.osd_client = OsdClient(self.params)
def test_create_target(self):
"""
Execute the test of creating a iscsi target
"""
iscsi_target_name = utils.utils_misc.generate_random_string(6)
delay_time = time.strftime("%Y-%m", time.localtime(time.time()))
iscsi_target_name = "iqn." + delay_time + ".com.lenovo:" + iscsi_target_name
LOG.info("Target_name is %s" % iscsi_target_name)
body = {
'initiator_ips': '192.168.1.30',
'target_name': iscsi_target_name,
'multipath': self.params.get('multipath', '1'),
'gateway_id': self.gateway_id
}
resp = self.client.create(**body)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create target failed: %s" % body)
self.env['iscsi_target'] = resp.body
def test_create(self):
"""
Execute the test of creating a pool
"""
test_utils.update_env_vgroup(self.params, self.env)
pool_name = 'cloudtest_' + utils_misc.generate_random_string(6)
if self.params.get('NO_EC', "true") == "true":
LOG.info("Try to create NO_EC pool")
create_pool = {
'name': pool_name,
'size': self.params.get('rest_arg_size', 3),
'group_id': self.params.get('rest_arg_group_id', 1),
'pg_num': self.params.get('rest_arg_pg_num', 448),
'vgroup_id': self.env.get('vgroup_id', 1)
}
else:
LOG.info("Try to create EC pool")
create_pool = {
'name': pool_name,
'group_id': self.params.get('rest_arg_group_id', 1),
'pg_num': self.params.get('rest_arg_pg_num', 448),
'vgroup_id': self.env.get('vgroup_id', 1),
'safe_type': self.params.get('safe_type', 0),
'data_block_num': self.params.get('data_block_num', 3),
'code_block_num': self.params.get('code_block_num', 0),
'min_size': self.params.get('min_size', 1),
'max_bytes': self.params.get("max_bytes", 486547056640),
'write_mode': self.params.get("write_mode", "writeback"),
}
resp = self.client.create(**create_pool)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create pool failed: %s" % self.body)
self.env['pool_tmp_id'] = resp.body['properties']['context']['pool_id']
status = test_utils.wait_for_pool_created(self.client, pool_name)
if not status:
raise exceptions.TestFail('Failed to create pool %s' % pool_name)
LOG.info('Create pool %s successfully !' % pool_name)
def test_create(self):
"""
Execute the test of creating a gateway
"""
gateway_name = 'cloudtest_gw_' + utils_misc.generate_random_string(6)
create_gateway = {
'name': gateway_name,
'services': self.params.get('services', 'iSCSI'),
'public_ip': self.params.get('public_ip', "192.168.1.21/24")
}
node_list = []
server_id = test_utils.get_available_server(self.params)
sub_node = {
"id": server_id,
"interface": self.params.get('create_node_interface', 'eth0')
}
node_list.append(sub_node)
resp = self.client.create(node_list, **create_gateway)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Create gateway failed: %s" % self.body)
self.env['gateway_name'] = resp.body['properties']['name']
def test_export_to_remote(self):
"""
Test export log to remote
"""
ceph_server_ip = self.params.get('ceph_management_url')
controller_ip = test_utils.get_ip_from_string(ceph_server_ip)
controller_username = self.params.get('ceph_server_ssh_username')
controller_password = self.params.get('ceph_server_ssh_password')
file_name = 'cjtest11.txt'
export_log = {
'host': controller_ip,
'password': controller_password,
'path': '/tmp',
'port': 22,
'username': controller_username,
'filename': file_name,
}
resp = self.client.export_log(**export_log)
LOG.info('Rest Response: %s' % resp)
if not resp and utils.verify_response(self.body, resp):
raise exceptions.TestFail("Export log to remote job failed: %s" %
self.body)
def __enable_qos(self, body):
LOG.info('******Enable qos******')
resp = self.qos_client.enable(**body)
if not utils.verify_response(body, resp.body.get('results')):
raise exceptions.TestFail("Enable qos failed: %s" % body)
def _set_cluster_configuration(self, body):
resp = self.client.set(self.cluster_id, body)
if not resp and utils.verify_response(body, resp):
raise exceptions.TestFail("Set cluster conf failed: %s" % body)
LOG.info("Set cluster configuration successfully: %s" % body)
