def __safe_env_save(self, env): """ Treat "env.save()" exception as warnings :param env: The virttest env object :return: True on failure """ try: env.save() except Exception as details: if hasattr(stacktrace, "str_unpickable_object"): self.log.warn("Unable to save environment: %s", stacktrace.str_unpickable_object(env.data)) else: # TODO: Remove when 36.0 LTS is not supported self.log.warn("Unable to save environment: %s (%s)", details, env.data) return True return False
def _safe_env_save(self, env): """ Treat "env.save()" exception as warnings :param env: The virttest env object :return: True on failure """ try: env.save() except Exception as details: try: pickle.dumps(env.data) except Exception: self.log.warn("Unable to save environment: %s", stacktrace.str_unpickable_object(env.data)) else: self.log.warn("Unable to save environment: %s (%s)", details, env.data) return True return False
def __safe_env_save(self, env): """ Treat "env.save()" exception as warnings :param env: The virttest env object :return: True on failure """ try: env.save() except Exception as details: try: pickle.dumps(env.data) except Exception: self.log.warn("Unable to save environment: %s", stacktrace.str_unpickable_object(env.data)) else: self.log.warn("Unable to save environment: %s (%s)", details, env.data) return True return False
def check(exps, obj): """ Search exps in the output of str_unpickable_object(obj) """ act = stacktrace.str_unpickable_object(obj) for exp in exps: if not re.search(exp, act): self.fail("%r no match in:\n%s" % (exp, act))
def check(exps, obj): """ Search exps in the output of str_unpickable_object(obj) """ act = stacktrace.str_unpickable_object(obj) for exp in exps: if not re.search(exp, act): self.fail("%r no match in:\n%s" % (exp, act))
def _run_test(job, result, test_factory, queue): """ Run a test instance. This code is the first thing that runs inside a new process, known here as the test process. It communicates to the test runner by using :param:`queue`. It's important that this early state is given to the test runner in a reliable way. :param test_factory: Test factory (test class and parameters). :type test_factory: tuple of :class:`avocado.core.test.Test` and dict. :param queue: Multiprocess queue. :type queue: :class:`multiprocessing.Queue` instance. """ sys.stdout = output.LoggingFile(["[stdout] "], loggers=[TEST_LOG]) sys.stderr = output.LoggingFile(["[stderr] "], loggers=[TEST_LOG]) def sigterm_handler(signum, frame): # pylint: disable=W0613 """ Produce traceback on SIGTERM """ raise RuntimeError("Test interrupted by SIGTERM") signal.signal(signal.SIGTERM, sigterm_handler) # At this point, the original `sys.stdin` has already been # closed and replaced with `os.devnull` by # `multiprocessing.Process()` (not directly from Avocado # code). Still, tests trying to use file descriptor 0 would # be able to read from the tty, and would hang. Let's replace # STDIN fd (0), with the same fd previously set by # `multiprocessing.Process()` os.dup2(sys.stdin.fileno(), 0) instance = loader.load_test(test_factory) if instance.runner_queue is None: instance.set_runner_queue(queue) early_state = instance.get_state() early_state['early_status'] = True try: queue.put(early_state) except queueFullException: instance.error(stacktrace.str_unpickable_object(early_state)) result.start_test(early_state) job.result_events_dispatcher.map_method('start_test', result, early_state) if job.config.get('run.log_test_data_directories'): data_sources = getattr(instance, "DATA_SOURCES", []) if data_sources: locations = [] for source in data_sources: locations.append(instance.get_data("", source=source, must_exist=False)) TEST_LOG.info('Test data directories: ') for source, location in zip(data_sources, locations): if location is not None: TEST_LOG.info(' %s: %s', source, location) TEST_LOG.info('') try: instance.run_avocado() finally: try: state = instance.get_state() queue.put(state) except queueFullException: instance.error(stacktrace.str_unpickable_object(state))