def test_delete_bucket(self):
if 'group_id' in self.env:
group_id = self.env.get('group_id')
elif self.params.get('group_id'):
group_id = int(self.params.get('group_id'))
else:
raise exceptions.TestSetupFail(
'Please set group_id in config first')
if 'bucket_id' in self.env:
bucket_id = self.env.get('bucket_id')
elif self.params.get('bucket_id'):
bucket_id = int(self.params.get('bucket_id'))
else:
raise exceptions.TestSetupFail(
'Please set bucket_id in config first')
self.client.delete_bucket(group_id, bucket_id)
# Verify the deleted bucket_id cannot be found in list
groups = self.client.list_groups(extra_url='?underlying=1')
result = []
for group in groups:
if group_id == group['id']:
self._find_bucket_id(group.get('items'),
bucket_id, result)
break
if any(result):
raise exceptions.TestFail("Failed to delete bucket %d!"
% bucket_id)
else:
LOG.info("Delete the bucket %d successfully!" % bucket_id)
del self.env['bucket_id']
def _test_node(self, computenode_ipaddr):
result_speccpu_node = None
result_fio_node = None
result_stream_node = None
LOG.debug("Start testing on node %s" % self.availability_zone)
session_node = self.get_session_computenode(computenode_ipaddr)
ovs_config_orig = self.get_ovsconfig(session_node)
self.set_ovsconfig(session_node, self.params["dpdk_mem"],
self.params["cpu_mask"])
LOG.debug("Create a rbd image and full fill it on compute node")
self.rbdimagename = self.get_newrbdimagename(session_node)
if self.rbdimagename is None:
raise exceptions.TestSetupFail("Failed to get a new image name")
LOG.info("New image name is %s" % self.rbdimagename)
if not (self.create_fullfill_rbdimage_node(
session_node, self.rbdimagename, self.image_sizeingb,
self.fio_workdir_node)):
raise exceptions.TestSetupFail("Failed to create rbd image")
self.cleanup_rbdimage = True
casetype = "node"
LOG.info("Run SpecCPU testing on node")
exit_status = self.check_speccpu(self.speccpu_workdir_node,
session_node)
if exit_status == 0:
result_speccpu_node = self.dospeccpu(self.speccpu_workdir_node,
session_node,
self.speccpu_timeout,
self.times, casetype)
else:
LOG.info("SpecCPU is not ready on node")
LOG.info("Run Stream testing on node")
exit_status = self.check_stream(self.stream_workdir_node, session_node)
if exit_status == 0:
result_stream_node = self.dostream(self.stream_workdir_node,
session_node,
self.stream_timeout, self.times,
casetype)
else:
LOG.info("Stream is not ready on node")
LOG.info("Run FIO testing on node")
exit_status = self.check_fio(self.fio_workdir_node, session_node)
if exit_status == 0:
result_fio_node = self.dofio(self.fio_workdir_node, session_node,
self.fio_timeout, self.rbdimagename,
self.times, casetype,
self.image_sizeingb)
else:
LOG.info("FIO is not ready on node")
self.recover_ovsconfig(session_node, ovs_config_orig)
return result_speccpu_node, result_stream_node, result_fio_node
def setup(self):
self.aggregate_name = "cloudtest_aggregate_" + \
utils_misc.generate_random_string(6)
self.host_zone = "cloudtest_az_" + \
utils_misc.generate_random_string(6)
self.flavor_name = self.params["flavor_name"]
self.vmtobeactive_timeout = int(self.params["vmtobeactive_timeout"])
self.computenodes_name = []
self.availability_zone = None
self.aggregate = None
hypervisors = self.compute_utils.get_all_hypervisors()
LOG.debug("hypervisors: %s" % hypervisors)
if len(hypervisors) >= 2:
for i in range(2):
self.computenodes_name.append(hypervisors[i].hypervisor_hostname)
else:
raise exceptions.TestSetupFail(
"No enough hypervisor to create aggregate")
LOG.debug("Got computes :%s" % self.computenodes_name)
self.availability_zone = self.host_zone
aggregates = self.compute_utils.novaclient.aggregates.list()
LOG.debug("Aggregate have had:%s" % aggregates)
for ag in aggregates:
LOG.debug("ag:%s" % ag)
for host in ag.hosts:
LOG.debug("host:%s" % host)
for computenode_name in self.computenodes_name:
LOG.debug("computenode_name:%s" % computenode_name)
if host == computenode_name:
LOG.debug("host:%s belongs other aggregate" % host)
raise exceptions.TestSetupFail(
"Failed to add host %s to a new aggregate, "
"it already belongs to other" %
computenode_name)
LOG.info("Create a new aggregate %s with availability zone %s"
% (self.aggregate_name, self.availability_zone))
self.aggregate = self.compute_utils.novaclient.aggregates.create(
self.aggregate_name, self.host_zone)
self.cleanup_aggregate = True
for computenode_name in self.computenodes_name:
LOG.info("Add compute %s to aggregate %s" %
(computenode_name, self.aggregate_name))
self.compute_utils.novaclient.aggregates.add_host(self.aggregate,
computenode_name)
self.cleanup_aggregate_host = True
def copy_nfs_image(params, root_dir, basename=False):
"""
copy image from image_path to nfs mount dir if image is not available
or corrupted.
:param params: Test dict params
:param root_dir: Base directory for relative filenames.
:param basename: True to use only basename of image name
:raise: TestSetupFail if image is unavailable/corrupted
"""
if params.get("setup_local_nfs", "no") == "yes":
# check for image availability in NFS shared path
base_dir = params["nfs_mount_dir"]
dst = get_image_filename(params, base_dir, basename=basename)
if (not os.path.isfile(dst) or
utils_misc.get_image_info(dst)['lcounts'].lower() == "true"):
source = get_image_filename(params, root_dir)
logging.debug(
"Checking for image available in image data "
"path - %s", source)
# check for image availability in images data directory
if (os.path.isfile(source) and
not utils_misc.get_image_info(source)['lcounts'].lower()
== "true"):
logging.debug("Copying guest image from %s to %s", source, dst)
shutil.copy(source, dst)
else:
raise exceptions.TestSetupFail("Guest image is unavailable"
"/corrupted in %s and %s" %
(source, dst))
def copy_nfs_image(params, image_name, root_dir):
"""
copy image from image_path to nfs mount dir if image is not available
or corrupted.
:param params: Test dict params
:param image_name: Master image name.
:param root_dir: Base directory for relative filenames.
:raise: TestSetupFail if image is unavailable/corrupted
"""
image_format = params.get("image_format", "qcow2")
if params.get("setup_local_nfs", "no") == "yes":
# check for image availability in NFS shared path
base_dir = params.get("images_base_dir", data_dir.get_data_dir())
dst = get_image_filename(params, base_dir)
if (not os.path.isfile(dst) or
utils_misc.get_image_info(dst)['lcounts'].lower() == "true"):
source = os.path.join(root_dir, "images", image_name)
if image_format not in source:
source = "%s.%s" % (source, image_format)
logging.debug(
"Checking for image available in image data "
"path - %s", source)
# check for image availability in images data directory
if (os.path.isfile(source) and
not utils_misc.get_image_info(source)['lcounts'].lower()
== "true"):
logging.debug("Copying guest image from %s to %s", source, dst)
shutil.copy(source, dst)
else:
raise exceptions.TestSetupFail("Guest image is unavailable"
"/corrupted in %s and %s" %
(source, dst))
def __set_params(self):
if not self.params.get('rest_arg_des_cluster_id'):
clusters = test_utils.get_available_clusters(self.params)
if len(clusters) < 2:
raise exceptions.TestSetupFail(
'There are not enough clusters!')
for cluster in clusters:
if cluster['id'] != self.cluster_id:
self.des_cluster_id = cluster['id']
self.params['rest_arg_des_cluster_id'] = cluster['id']
LOG.info("des_cluster_id = %s" % self.des_cluster_id)
break
src_host = test_utils.get_available_server_info(self.params,
self.cluster_id)
self.src_ip = src_host['publicip']
self.params['rest_arg_src_ip'] = self.src_ip
LOG.info('src_ip = %s' % self.src_ip)
self.src_host_id = src_host['id']
self.params['rest_arg_src_host_id'] = self.src_host_id
LOG.info('src_host_id = %s' % self.src_host_id)
des_host = test_utils.get_available_server_info(self.params,
self.des_cluster_id)
self.des_ip = des_host['publicip']
self.params['rest_arg_des_ip'] = self.des_ip
LOG.info('des_ip = %s' % self.des_ip)
self.des_host_id = des_host['id']
self.params['rest_arg_des_host_id'] = self.des_host_id
LOG.info('des_host_id = %s' % self.des_host_id)
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 setup(self):
"""
Set up before executing test
"""
if 'cluster' in self.env:
self.cluster_id = self.env.get('cluster')
elif self.params.get('cluster_id'):
self.cluster_id = int(self.params.get('cluster_id'))
else:
raise exceptions.TestSetupFail(
'Please set cluster_id in config first')
self.params['cluster_id'] = self.cluster_id
self.client = ServersClient(self.params)
self.ipv6 = self.params.get('IPV6', False)
if self.ipv6 == False:
self.controller_ip = self.params.get('ceph_management_url').split(
':')[1].strip('/')
else:
self.controller_ip = re.findall(
r"[http|https]://\[(.*)\].*",
self.params.get('ceph_management_url'),
flags=0)[0]
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 _run_test(self):
"""
Auxiliary method to run setup and test method.
"""
self._tag_start()
testMethod = getattr(self, self._testMethodName)
skip_test_condition = getattr(testMethod, '__skip_test_condition__', False)
skip_test_condition_negate = getattr(testMethod, '__skip_test_condition_negate__', False)
if skip_test_condition:
if callable(skip_test_condition):
if skip_test_condition_negate:
self.__skip_test = not bool(skip_test_condition(self))
else:
self.__skip_test = bool(skip_test_condition(self))
else:
if skip_test_condition_negate:
self.__skip_test = not bool(skip_test_condition)
else:
self.__skip_test = bool(skip_test_condition)
else:
self.__skip_test = bool(skip_test_condition)
try:
if self.__skip_test is False:
self.__phase = 'SETUP'
self.setUp()
except exceptions.TestSkipError as details:
self.__skip_test = True
stacktrace.log_exc_info(sys.exc_info(), logger=LOG_JOB)
raise exceptions.TestSkipError(details)
except exceptions.TestCancel:
stacktrace.log_exc_info(sys.exc_info(), logger=LOG_JOB)
raise
except: # Old-style exceptions are not inherited from Exception()
stacktrace.log_exc_info(sys.exc_info(), logger=LOG_JOB)
details = sys.exc_info()[1]
raise exceptions.TestSetupFail(details)
else:
try:
self.__phase = 'TEST'
if inspect.iscoroutinefunction(testMethod):
loop = asyncio.get_event_loop()
loop.run_until_complete(testMethod())
else:
testMethod()
except exceptions.TestCancel:
stacktrace.log_exc_info(sys.exc_info(), logger=LOG_JOB)
raise
except: # Old-style exceptions are not inherited from Exception() pylint: disable=W0702
stacktrace.log_exc_info(sys.exc_info(), logger=LOG_JOB)
details = sys.exc_info()[1]
if not isinstance(details, Exception): # Avoid passing nasty exc
details = exceptions.TestError(f"{details!r}: {details}")
self.log.debug("Local variables:")
local_vars = inspect.trace()[1][0].f_locals
for key, value in local_vars.items():
self.log.debug(' -> %s %s: %s', key, type(value), value)
raise details
self.__status = 'PASS'
def get_ovsconfig(self, session):
cmd_ovsconf = ("ovs-vsctl --no-wait get Open_vSwitch . other_config")
_run_result_ovsconf = session.run(cmd_ovsconf)
if _run_result_ovsconf.exit_status != 0:
raise exceptions.TestSetupFail("Failed to get OVS config")
_ovs_config_orig = self.get_ovsconfig_fromstr(
_run_result_ovsconf.stdout[1:len(_run_result_ovsconf.stdout) - 2])
return _ovs_config_orig
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 setup(self):
if self.env.get('cluster'):
self.cluster_id = self.env.get('cluster')
elif self.params.get('cluster_id'):
self.cluster_id = self.params.get('cluster_id')
else:
raise exceptions.TestSetupFail(
'Please set cluster_id in config first')
if self.env.get('server'):
self.server_id = self.env.get('server')
elif self.params.get('server_id'):
self.server_id = self.params.get('server_id')
else:
raise exceptions.TestSetupFail(
'Please set server_id in config first')
self.monitor_ops = self.params.get('monitor_operation')
def setup(self):
self.vm_1_name = 'cloudtest_' + utils_misc.generate_random_string(6)
self.vm_2_name = 'cloudtest_' + utils_misc.generate_random_string(6)
LOG.info("Try to get two compute nodes")
hyors = self.compute_utils.novaclient.hypervisors.list()
if len(hyors) < 2:
raise exceptions.TestSetupFail(
"Failed to get enough compute nodes")
hyors_index = self.get_randomindex(len(hyors), 2)
LOG.info("Try to get compute node ip.")
computenode_ip = self.get_computenode_ip(
hyors[hyors_index[0]]._info["service"]["host"])
LOG.info("Got compute node ip :%s" % computenode_ip)
self.session_computenode = self.get_session_computenode(computenode_ip,
usekey=True)
LOG.info("To check if it supports nic bonding")
self.nicbonding = self.get_nic_bonding(self.session_computenode)
if self.nicbonding is None:
raise exceptions.TestSkipError("Did not find bonding nic, "
"skip the test")
else:
LOG.info("Got a bonding nic %s" % self.nicbonding)
self.vm1 = self.create_vm_with_az(
self.vm_1_name, hyors[hyors_index[0]]._info["service"]["host"])
self.register_cleanup(self.vm1)
self.vm2 = self.create_vm_with_az(
self.vm_2_name, hyors[hyors_index[1]]._info["service"]["host"])
self.register_cleanup(self.vm2)
self.compute_utils.assign_floating_ip_to_vm(self.vm1)
self.compute_utils.assign_floating_ip_to_vm(self.vm2)
self.ipaddr_1 = self.compute_utils.get_vm_ipaddr(self.vm_1_name)
self.ipaddr_2 = self.compute_utils.get_vm_ipaddr(self.vm_2_name)
time.sleep(10)
self.session_vm = test_utils.get_host_session(
self.params, 'instance', self.ipaddr_1["floating"])
checkpath = "/etc/sysconfig/network-scripts"
self.nics = self.get_eths_forbonded(self.session_computenode,
checkpath, self.nicbonding)
if len(self.nics) == 0:
raise exceptions.TestSetupFail("Failed to get bonded nic")
LOG.info("%s bonded to be %s" % (self.nics, self.nicbonding))
def setup(self):
# Super called after VM is found and initialized
if self.args.vm_domain is None:
e_msg = ('Please set Virtual Machine Domain with option '
'--vm-domain.')
self.stream.notify(event='error', msg=e_msg)
raise exceptions.TestSetupFail(e_msg)
if self.args.vm_hostname is None:
e_msg = ('Please set Virtual Machine hostname with option '
'--vm-hostname.')
self.stream.notify(event='error', msg=e_msg)
raise exceptions.TestSetupFail(e_msg)
self.stream.notify(event='message',
msg="DOMAIN : %s" % self.args.vm_domain)
self.vm = virt.vm_connect(self.args.vm_domain,
self.args.vm_hypervisor_uri)
if self.vm is None:
self.stream.notify(event='error',
msg="Could not connect to VM '%s'" %
self.args.vm_domain)
raise exceptions.TestSetupFail()
if self.vm.start() is False:
self.stream.notify(event='error',
msg="Could not start VM '%s'" %
self.args.vm_domain)
raise exceptions.TestSetupFail()
assert self.vm.domain.isActive() is not False
if self.args.vm_cleanup is True:
self.vm.create_snapshot()
if self.vm.snapshot is None:
self.stream.notify(event='error',
msg="Could not create "
"snapshot on VM '%s'" % self.args.vm_domain)
raise exceptions.TestSetupFail()
try:
# Finish remote setup and copy the tests
self.args.remote_hostname = self.args.vm_hostname
self.args.remote_username = self.args.vm_username
self.args.remote_password = self.args.vm_password
self.args.remote_no_copy = self.args.vm_no_copy
super(VMTestResult, self).setup()
except Exception:
self.tear_down()
raise
def set_ovsconfig(self, session, dpdk_mem, cpu_mask):
LOG.info("To get OVS config original")
ovs_config_orig = self.get_ovsconfig(session)
LOG.info("OVS config is: %s" % ovs_config_orig)
LOG.info("To set OVS config for memory")
cmd_ovsmem_set = ("ovs-vsctl set Open_vSwitch . "
"other_config:dpdk-socket-mem=\"%s\"" % dpdk_mem)
_run_result_ovsmem_set = session.run(cmd_ovsmem_set)
if _run_result_ovsmem_set.exit_status != 0:
raise exceptions.TestSetupFail(
"Failed to set OVS config for memory")
ovs_config_mem_set = self.get_ovsconfig(session)
LOG.info("Set mem to: %s" % ovs_config_mem_set)
LOG.info("To set OVS config for CPU")
cmd_ovscpu_set = ("ovs-vsctl set Open_vSwitch . "
"other_config:pmd-cpu-mask=\"%s\"" % cpu_mask)
_run_result_ovscpu_set = session.run(cmd_ovscpu_set)
if _run_result_ovscpu_set.exit_status != 0:
raise exceptions.TestSetupFail("Failed to set OVS config for CPU")
ovs_config_cpu_set = self.get_ovsconfig(session)
LOG.info("Set cpu to: %s" % ovs_config_cpu_set)
def recover_ovsconfig(self, session, ovs_config_orig):
LOG.info("To recover OVS config for CPU")
cmd_ovscpu_recover = ("ovs-vsctl set Open_vSwitch . "
"other_config:pmd-cpu-mask=\"%s\"" %
ovs_config_orig["pmd-cpu-mask"])
_run_result_ovscpu_recover = session.run(cmd_ovscpu_recover)
if _run_result_ovscpu_recover.exit_status != 0:
raise exceptions.TestSetupFail(
"Failed to recover OVS config for CPU")
ovs_config_cpu_recover = self.get_ovsconfig(session)
LOG.info("Recover cpu to: %s" % ovs_config_cpu_recover)
LOG.info("To recover OVS config for memory")
cmd_ovsmem_recover = ("ovs-vsctl set Open_vSwitch . "
"other_config:dpdk-socket-mem=\"%s\"" %
ovs_config_orig["dpdk-socket-mem"])
_run_result_ovsmem_recover = session.run(cmd_ovsmem_recover)
if _run_result_ovsmem_recover.exit_status != 0:
raise exceptions.TestSetupFail(
"Failed to recover OVS config for memory")
ovs_config_mem_recover = self.get_ovsconfig(session)
LOG.info("Recover mem to: %s" % ovs_config_mem_recover)
def test_rename_bucket(self):
if 'group_id' in self.env:
group_id = self.env.get('group_id')
elif self.params.get('group_id'):
group_id = int(self.params.get('group_id'))
else:
raise exceptions.TestSetupFail(
'Please set group_id in config first')
if 'bucket_id' in self.env:
bucket_id = self.env.get('bucket_id')
elif self.params.get('bucket_id'):
bucket_id = int(self.params.get('bucket_id'))
else:
raise exceptions.TestSetupFail(
'Please set bucket_id in config first')
rename_body = {'name': 'cloudtest_bucket_'
+ utils_misc.generate_random_string(6)}
resp_body = self.client.rename_bucket(group_id,
bucket_id, **rename_body)
body = resp_body.body
if body['name'] != rename_body['name']:
raise exceptions.TestFail("Failed to rename the bucket to %s!"
% rename_body['name'])
# Verify the bucket name can be found in list
groups = self.client.list_groups(extra_url='?underlying=1')
result = []
for group in groups:
if group_id == group['id']:
self._find_bucket_name(group.get('items'),
rename_body['name'], result)
break
if any(result):
LOG.info("Rename the bucket to %s successfully!"
% rename_body['name'])
else:
raise exceptions.TestFail(
"Failed to rename the bucket to %s!"
% rename_body['name'])
def test_modify_bucket(self):
if 'group_id' in self.env:
group_id = self.env.get('group_id')
elif self.params.get('group_id'):
group_id = int(self.params.get('group_id'))
else:
raise exceptions.TestSetupFail(
'Please set group_id in config first')
if 'bucket_id' in self.env:
bucket_id = self.env.get('bucket_id')
elif self.params.get('bucket_id'):
bucket_id = int(self.params.get('bucket_id'))
else:
raise exceptions.TestSetupFail(
'Please set bucket_id in config first')
# test not specified optional parameter parent_id
target_group_id = self.params.get('rest_arg_target_group')
if not target_group_id:
target_group_id, parent_id = \
test_utils.get_available_group_bucket(self.params,
group_id)
modify_body = {'target_group': int(target_group_id)}
self.client.modify_bucket(group_id, bucket_id, **modify_body)
self._verify_modify_bucket(modify_body, None, bucket_id)
group_id = target_group_id
# test specified optional parameter parent_id
parent_id = self.params.get('rest_arg_parent_id')
if not parent_id:
target_group_id, parent_id = \
test_utils.get_available_group_bucket(self.params)
modify_body.update({'target_group': int(target_group_id),
'parent_id': int(parent_id)})
self.client.modify_bucket(group_id, bucket_id, **modify_body)
self._verify_modify_bucket(modify_body, parent_id, bucket_id)
self.env['group_id'] = modify_body['target_group']
self.env['bucket_id'] = bucket_id
def setup(self):
if self.env.get('cluster'):
self.cluster_id = self.env.get('cluster')
elif self.params.get('cluster_id'):
self.cluster_id = self.params.get('cluster_id')
else:
raise exceptions.TestSetupFail(
'Please set cluster_id in config first')
self.server_id = test_utils.get_available_server(self.params)
self.osd_id = test_utils.get_osd_id_stateless(server_id=self.server_id,
params=self.params)
def create_vm(self):
LOG.info("Create VM on availability zone %s" % self.availability_zone)
vm_name = 'cloudtest_' + utils_misc.generate_random_string(6)
vm = self.compute_utils.create_vm(vm_name=vm_name,
image_name=self.params["image_name"],
flavor_name=self.flavor_name,
network_name=self.params["network_name"],
injected_key=None, sec_group=None,
availability_zone=self.availability_zone)
vm_created = self.compute_utils.wait_for_vm_active(vm, 1,
self.vmtobeactive_timeout)
if vm_created == False:
raise exceptions.TestSetupFail("Failed to creating VM")
self.register_cleanup(vm)
return vm
def test_list_groups(self):
if 'group_id' in self.env:
group_id = self.env.get('group_id')
elif self.params.get('group_id'):
group_id = int(self.params.get('group_id'))
else:
raise exceptions.TestSetupFail(
'Please set group_id in config first')
groups = self.client.list_groups()
for group in groups:
if group_id == group['id']:
return
raise exceptions.TestFail(
"Failed to find previously created group")
def create_vm_with_az(self, vm_name, hyor):
host_zone = self.compute_utils.get_host_by_name(host_name=hyor).zone
az = '%s:%s' % (host_zone, hyor)
vm = self.compute_utils.create_vm(
vm_name=vm_name,
image_name=self.params["image_name"],
flavor_name=self.params["flavor_name"],
network_name=self.params["network_name"],
injected_key=None,
sec_group=None,
availability_zone=az)
vm_created = self.compute_utils.wait_for_vm_active(
vm, 1, int(self.params["vmtobeactive_timeout"]))
if vm_created == False:
raise exceptions.TestSetupFail("Quit for creating vm timeout")
return vm
def test_delete_group(self):
if 'group_id' in self.env:
group_id = self.env.get('group_id')
elif self.params.get('group_id'):
group_id = int(self.params.get('group_id'))
else:
raise exceptions.TestSetupFail(
'Please set group_id in config first')
self.client.delete_group(group_id)
groups = self.client.list_groups()
for group in groups:
if group_id in group.values():
raise exceptions.TestFail(
"Failed to delete group: %s" % group_id)
del self.env['group_id']
def runTest(self, result=None):
"""
Run test method, for compatibility with unittest.TestCase.
:result: Unused param, compatibiltiy with :class:`unittest.TestCase`.
"""
sysinfo_logger = sysinfo.SysInfo(basedir=self.sysinfodir)
self.start_logging()
sysinfo_logger.start_job_hook()
action_exception = None
cleanup_exception = None
try:
self.setup()
except Exception, details:
log_exc_info(sys.exc_info())
raise exceptions.TestSetupFail(details)
def test(self):
rst_speccpu_vm = None
rst_stream_vm = None
rst_fio_vm = None
rst_speccpu_node = None
rst_stream_node = None
rst_fio_node = None
#Benchmark SpecCPU, Stream, FIO on VM
rst_speccpu_vm, rst_stream_vm, rst_fio_vm = self._test_vm()
LOG.debug("Scp the limit config file for node to %s" %
self.params["computenode"])
cmd_scp_3 = (
"scp %s_node %s@%s:/boot/grub2/grub.cfg" %
(self.confallpath, self.computenode_username, self.computenode_ip))
cloudtest.remote.remote_scp(cmd_scp_3, self.computenode_password)
session_node = self.get_session_computenode(self.computenode_ip)
LOG.info("Reboot %s for running node job" % self.params["computenode"])
self.reboot_computenode(session_node)
retval = self.wait_poweron_computenode(self.computenode_ip, 80)
LOG.debug("Return value of reboot %s: %s" %
(self.params["computenode"], retval))
if retval != 0:
raise exceptions.TestSetupFail(
"Compute node did not reboot successfully")
session_node = self.get_session_computenode(self.computenode_ip)
self.cpucores = self.get_cpu_cores(session_node)
LOG.debug("%s has CPU cores : %d" %
(self.params["computenode"], self.cpucores[1]))
LOG.info("Set %s CPU cores to be offline from core-%d to core-%d" %
(self.params["computenode"],
int(self.cpucores[1] - int(self.params["cpu_offline_from"]) +
1), self.cpucores[1]))
self.set_cpu_cores(
int(self.cpucores[1] - int(self.params["cpu_offline_from"]) + 1),
self.cpucores[1], "offline", session_node)
self.cleanup_cpucore = True
LOG.debug("Start to run test on %s" % self.params["computenode"])
#Benchmark SpecCPU, Stream, FIO on compute node
rst_speccpu_node, rst_stream_node, rst_fio_node = self._test_node(
self.computenode_ip)
self.compare_results(rst_speccpu_vm, rst_speccpu_node, rst_stream_node,
rst_stream_vm, rst_fio_node, rst_fio_vm)
def setup(self):
"""
Set up before executing test
"""
if self.env.get('cluster'):
self.cluster_id = self.env.get('cluster')
elif self.params.get('cluster_id'):
self.cluster_id = int(self.params.get('cluster_id'))
else:
raise exceptions.TestSetupFail(
'Please set cluster_id in config first')
self.params['cluster_id'] = self.cluster_id
self.client = SnapshotsGroupClient(self.params)
self.pool_count = int(self.params.get('pool_count'))
self.rbd_count_of_per_pool = int(
self.params.get('rbd_count_of_per_pool'))
def runTest(self, result=None):
"""
Run test method, for compatibility with unittest.TestCase.
:result: Unused param, compatibiltiy with :class:`unittest.TestCase`.
"""
self.start_logging()
self.sysinfo_logger.start_test_hook()
action_exception = None
cleanup_exception = None
stdout_check_exception = None
stderr_check_exception = None
try:
self.setup()
except Exception, details:
stacktrace.log_exc_info(sys.exc_info(), logger='avocado.test')
raise exceptions.TestSetupFail(details)
def setup(self):
"""
Set up before executing test
"""
if 'cluster' in self.env:
self.cluster_id = self.env.get('cluster')
elif self.params.get('cluster_id'):
self.cluster_id = int(self.params.get('cluster_id'))
else:
raise exceptions.TestSetupFail(
'Please set cluster_id in config first')
self.params['cluster_id'] = self.cluster_id
self.client = RemoteBackupClient(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 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 setup(self):
"""
Set up before executing test
"""
if 'cluster' in self.env:
self.cluster_id = self.env['cluster']
elif self.params.get('cluster_id'):
self.cluster_id = self.params.get('cluster_id')
else:
raise exceptions.TestSetupFail(
"Please set cluster_id in config first")
zabbix_ip = remote.get_zabbix_server_ip(self.controller_ip,
self.controller_username,
self.controller_password)
self.params['rest_arg_zabbix_server_ip'] = zabbix_ip
self.params['rest_arg_ntp_server_ip'] = zabbix_ip
for k, v in self.params.items():
if 'rest_arg_' in k:
new_key = k.split('rest_arg_')[1]
self.body[new_key] = v
pre_body = {
"zabbix_server_ip": zabbix_ip,
"zabbix_user": "******",
"zabbix_password": "******",
"ntp_server_ip": "0.0.0.0",
"max_mdx_count": 4,
"max_mon_count": 4,
"daylight_begin": "23:00",
"daylight_end": "6:00",
"day_recover_bw": 1024,
"night_recover_bw": 1024
}
# get original configuration, used to restore env
configuration = self._query_cluster_configuration()
for key in pre_body.keys():
self.original_body[key] = configuration.get(key)
# pre-set
self._set_cluster_configuration(pre_body)
def setup(self):
if self.args.vm_domain is None:
e_msg = ('Please set Virtual Machine Domain with option '
'--vm-domain.')
self.stream.error(e_msg)
raise exceptions.TestSetupFail(e_msg)
if self.args.vm_hostname is None:
e_msg = ('Please set Virtual Machine hostname with option '
'--vm-hostname.')
self.stream.error(e_msg)
raise exceptions.TestSetupFail(e_msg)
self.stream.log_header("REMOTE TESTS: Virtual Machine Domain '%s'" %
self.args.vm_domain)
self.stream.log_header("REMOTE TESTS: Host login '%s@%s'" %
(self.args.vm_username, self.args.vm_hostname))
self.vm = virt.vm_connect(self.args.vm_domain,
self.args.vm_hypervisor_uri)
if self.vm is None:
self.stream.error("Could not connect to VM '%s'" % self.args.vm_domain)
raise exceptions.TestSetupFail()
if self.vm.start() is False:
self.stream.error("Could not start VM '%s'" % self.args.vm_domain)
raise exceptions.TestSetupFail()
assert self.vm.domain.isActive() is not False
if self.args.vm_cleanup is True:
self.vm.create_snapshot()
if self.vm.snapshot is None:
self.stream.error("Could not create snapshot on VM '%s'" % self.args.vm_domain)
raise exceptions.TestSetupFail()
try:
self.vm.setup_login(self.args.vm_hostname,
self.args.vm_username,
self.args.vm_password)
except Exception as err:
self.stream.error("Could not login on VM '%s': %s" % (self.args.vm_hostname,
err))
self.tear_down()
raise exceptions.TestSetupFail()
if self.vm.logged is False or self.vm.remote.uptime() is '':
self.stream.error("Could not login on VM '%s'" % self.args.vm_hostname)
self.tear_down()
raise exceptions.TestSetupFail()
self._copy_tests()
