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()