def _create_runtime_tasks_for_test(test_suite, runnable, no_digits, index, variant): """Creates runtime tasks for both tests, and for its requirements.""" result = [] # test related operations # create test ID if test_suite.name: prefix = "{}-{}".format(test_suite.name, index) else: prefix = index test_id = TestID(prefix, runnable.uri, variant, no_digits) # inject variant on runnable runnable.variant = dump_variant(variant) # handles the test task task = nrunner.Task( runnable, identifier=test_id, known_runners=nrunner.RUNNERS_REGISTRY_PYTHON_CLASS) runtime_task = RuntimeTask(task) result.append(runtime_task) # handles the requirements requirements_runtime_tasks = (Runner._get_requirements_runtime_tasks( runnable, prefix)) # extend the list of tasks with the requirements runtime tasks if requirements_runtime_tasks is not None: for requirement_runtime_task in requirements_runtime_tasks: # make sure we track the dependencies of a task runtime_task.task.dependencies.add( requirement_runtime_task.task) result.extend(requirements_runtime_tasks) return result
def _get_requirements_runtime_tasks(runnable, prefix): if runnable.requirements is None: return # creates the runnables for the requirements requirements_runnables = RequirementsResolver.resolve(runnable) requirements_runtime_tasks = [] # creates the tasks and runtime tasks for the requirements for requirement_runnable in requirements_runnables: name = '%s-%s' % (requirement_runnable.kind, requirement_runnable.kwargs.get('name')) # the human UI works with TestID objects, so we need to # use it to name other tasks task_id = TestID(prefix, name, None) # with --dry-run we don't want to run requirement if runnable.kind == 'dry-run': requirement_runnable.kind = 'noop' # creates the requirement task requirement_task = nrunner.Task(requirement_runnable, identifier=task_id, category='requirement') # make sure we track the dependencies of a task # runtime_task.task.dependencies.add(requirement_task) # created the requirement runtime task requirements_runtime_tasks.append(RuntimeTask(requirement_task)) return requirements_runtime_tasks
def _get_all_runtime_tasks(self, test_suite): result = [] no_digits = len(str(len(test_suite))) for index, task in enumerate(test_suite.tests, start=1): task.known_runners = nrunner.RUNNERS_REGISTRY_PYTHON_CLASS # this is all rubbish data test_id = TestID("{}-{}".format(test_suite.name, index), task.runnable.uri, None, no_digits) task.identifier = test_id result.append(RuntimeTask(task)) return result
def _get_all_runtime_tasks(test_suite): runtime_tasks = [] no_digits = len(str(len(test_suite))) status_uris = [test_suite.config.get('nrunner.status_server_uri')] for index, runnable in enumerate(test_suite.tests, start=1): # this is all rubbish data if test_suite.name: prefix = "{}-{}".format(test_suite.name, index) else: prefix = index test_id = TestID(prefix, runnable.uri, None, no_digits) task = nrunner.Task(runnable, test_id, status_uris, nrunner.RUNNERS_REGISTRY_PYTHON_CLASS) runtime_tasks.append(RuntimeTask(task)) return runtime_tasks
def test(self): number_of_tasks = 80 number_of_workers = 8 runnable = Runnable("noop", "noop") runtime_tasks = [RuntimeTask(Task(runnable, "%03i" % _)) for _ in range(1, number_of_tasks + 1)] spawner = Spawner() state_machine = statemachine.TaskStateMachine(runtime_tasks) loop = asyncio.get_event_loop() workers = [statemachine.Worker(state_machine, spawner).run() for _ in range(number_of_workers)] loop.run_until_complete(asyncio.gather(*workers)) self.assertEqual(number_of_tasks, len(state_machine.finished))
async def test(self): number_of_tasks = 80 number_of_workers = 8 runnable = Runnable("noop", "noop") runtime_tasks = [RuntimeTask(Task(runnable, "%03i" % _)) for _ in range(1, number_of_tasks + 1)] spawner = Spawner() status_repo = StatusRepo() state_machine = statemachine.TaskStateMachine(runtime_tasks, status_repo) workers = [statemachine.Worker(state_machine, spawner).run() for _ in range(number_of_workers)] await asyncio.gather(*workers) self.assertEqual(number_of_tasks, len(state_machine.finished))
async def run_test(self, job, node): """ Run a test instance inside a subprocess. :param job: job that includes the test suite :type job: :py:class:`avocado.core.job.Job` :param node: test node to run :type node: :py:class:`TestNode` """ if node.spawner is None: default_slot = self.slots[0] if len(self.slots) > 0 else "" node.set_environment(job, default_slot) # once the slot is set (here or earlier), the hostname reflects it hostname = node.params["hostname"] hostname = "localhost" if not hostname else hostname logging.debug(f"Running {node.id} on {hostname}") if not self.status_repo: self.status_repo = StatusRepo(job.unique_id) self.status_server = StatusServer( job.config.get('nrunner.status_server_listen'), self.status_repo) asyncio.ensure_future(self.status_server.serve_forever()) # TODO: this needs more customization asyncio.ensure_future(self._update_status(job)) raw_task = nrunner.Task(node.get_runnable(), node.id_test, [job.config.get('nrunner.status_server_uri')], nrunner.RUNNERS_REGISTRY_PYTHON_CLASS, job_id=self.job.unique_id) task = RuntimeTask(raw_task) self.tasks += [task] # TODO: use a single state machine for all test nodes when we are able # to at least add requested tasks to it safely (using its locks) await Worker( state_machine=TaskStateMachine([task], self.status_repo), spawner=node.spawner, max_running=1, task_timeout=job.config.get('task.timeout.running')).run()
def setUp(self): runnable = Runnable('noop', 'noop') task = Task('1-noop', runnable) self.runtime_task = RuntimeTask(task)
def setUp(self): runnable = Runnable("noop", "uri") task = Task(runnable, "1") self.runtime_task = RuntimeTask(task) self.spawner = MockRandomAliveSpawner()
def setUp(self): runnable = Runnable("noop", "uri") task = Task(runnable, "1") self.runtime_task = RuntimeTask(task) self.spawner = ProcessSpawner()
def setUp(self): runnable = Runnable("noop", "noop") task = Task(runnable, "1-noop") self.runtime_task = RuntimeTask(task)
def setUp(self): runnable = nrunner.Runnable('noop', 'uri') task = nrunner.Task(runnable, '1') self.runtime_task = RuntimeTask(task) self.spawner = MockRandomAliveSpawner()
def setUp(self): runnable = nrunner.Runnable('noop', 'uri') task = nrunner.Task(runnable, '1') self.runtime_task = RuntimeTask(task) self.spawner = ProcessSpawner()
def setUp(self): runnable = nrunner.Runnable('noop', 'uri') task = nrunner.Task('1', runnable) self.runtime_task = RuntimeTask(task) self.spawner = MockSpawner()