def _run(self, context): errors = [] items, iteration_steps = self._get_items_and_iteration_steps(context) for i in iteration_steps: values = items[i:i+len(self.vars)] exception = self._run_one_round(context, self.vars, values) if exception: if isinstance(exception, ExitForLoop): if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) break if isinstance(exception, ContinueForLoop): if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) continue if isinstance(exception, ExecutionPassed): exception.set_earlier_failures(errors) raise exception errors.extend(exception.get_errors()) if not exception.can_continue(context.in_teardown, self._templated, context.dry_run): break if errors: raise ExecutionFailures(errors)
def _run_loop(self, data, result): errors = [] executed = False for values in self._get_values_for_rounds(data): executed = True try: self._run_one_round(data, result, values) except BreakLoop as exception: if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) break except ContinueLoop as exception: if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) continue except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue(self._context, self._templated): break if errors: raise ExecutionFailures(errors) return executed
def wait_until(self, *threads): """ 指定一個或多個Thread, 等待指定的Thread皆結束工作後, 才繼續做接下來的動作。 Examples: | ${thread1} | Run Async | My Keyword 1 | arg1 | | Wait Until | ${thread1} | Examples: | ${thread1} | Run Async | My Keyword 1 | arg1 | | ${thread2} | Run Async | My Keyword 2 | arg2 | | ${thread3} | Run Async | My Keyword 3 | arg3 | | Wait Until | ${thread1} | ${thread2} | ${thread3} | """ for thread in threads: thread.join() time.sleep(1) if _errors: raise ExecutionFailures(_errors) _errors[:] = [] self._threads[:] = []
class Keywords(object): def __init__(self, steps, template=None): self._keywords = [] self._templated = bool(template) if self._templated: steps = [s.apply_template(template) for s in steps] for s in steps: self._add_step(s, template) def _add_step(self, step, template): if step.is_comment(): return if step.is_for_loop(): keyword = ForLoop(step, template) else: keyword = Keyword(step.keyword, step.args, step.assign) self.add_keyword(keyword) def add_keyword(self, keyword): self._keywords.append(keyword) def run(self, context): errors = [] for kw in self._keywords: try: kw.run(context) except ExecutionFailed, err: errors.extend(err.get_errors()) if not err.can_continue(context.teardown, self._templated, context.dry_run): break if errors: raise ExecutionFailures(errors)
def run_steps_parallel(self, steps): errors = [] threads = [] bucket = Queue() namedQueue[current_thread().name] = bucket try: for step in steps: threads.append(MyThread(bucket=bucket, target=self.run_step, args=(step,))) map(lambda x: x.start(), threads) map(lambda x: x.join(), threads) if current_thread().name == 'MainThread': root = ParallelLogNode('MainThread') post_order(root, root.children, self._context.output) root.children = [] if not bucket.empty(): raise bucket.get_nowait() else: if not bucket.empty(): error = bucket.get_nowait() namedQueue[current_thread().parent].put(error) raise error except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if errors: raise ExecutionFailures(errors)
def run(self, body): errors = [] for step in body: try: step.run(self._context, self._run, self._templated) except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) self._run = exception.can_continue(self._context, self._templated) if errors: raise ExecutionFailures(errors)
def _run(self, context): errors = [] items, iteration_steps = self._get_items_and_iteration_steps(context) for i in iteration_steps: values = items[i:i + len(self.vars)] err = self._run_one_round(context, self.vars, values) if err: if err.exit_for_loop: break errors.extend(err.get_errors()) if not err.can_continue(context.teardown, self._templated, context.dry_run): break if errors: raise ExecutionFailures(errors)
def run(self, context): errors = [] for kw in self._keywords: try: kw.run(context) except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue( context.in_teardown, self._templated, context.dry_run): break if errors: raise ExecutionFailures(errors)
def run_steps(self, steps): errors = [] for step in steps: try: self.run_step(step) except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue(self._context.in_teardown, self._templated, self._context.dry_run): break if errors: raise ExecutionFailures(errors)
def run_steps(self, steps): DebugLibrary.most_recent_step_runner = self errors = [] self.steps = [] self.og_steps = steps for step in steps: self.steps.append(step) while len(self.steps) > 0: self.cur_step = self.steps.pop(0) try: self.run_step(self.cur_step) except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue(self._context.in_teardown, self._templated, self._context.dry_run): break if errors: raise ExecutionFailures(errors)
def _run_loop(self, data, result): errors = [] for values in self._get_values_for_rounds(data): try: self._run_one_round(values, data, result) except ExitForLoop as exception: if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) break except ContinueForLoop as exception: if exception.earlier_failures: errors.extend(exception.earlier_failures.get_errors()) continue except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue(self._context.in_teardown, self._templated, self._context.dry_run): break if errors: raise ExecutionFailures(errors)
def run_steps(self, steps): from robot.api import logger logger.error('run_steps') logger.error(steps) debugLibrary = BuiltIn().get_library_instance('DebugLibrary') debugLibrary.most_recent_step_runner = self errors = [] self.steps = [] self.og_steps = steps from robot.api import logger logger.error('run steps before trigger check {}'.format(debugLibrary.debug_trigger)) if debugLibrary.debug_trigger: logger.error('run steps debug trigger') new_kwd = Keyword(name='Debug') self.steps.append(new_kwd) debugLibrary.debug_trigger = False for step in steps: self.steps.append(step) while len(self.steps) > 0: self.cur_step = self.steps.pop(0) try: self.run_step(self.cur_step) except ExecutionPassed as exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed as exception: errors.extend(exception.get_errors()) if not exception.can_continue(self._context.in_teardown, self._templated, self._context.dry_run): break if errors: raise ExecutionFailures(errors)
def run(self, data): run = self._run executed_once = False result = WhileResult(data.condition, data.limit) with StatusReporter(data, result, self._context, run) as status: if self._context.dry_run or not run: try: self._run_iteration(data, result, run) except (BreakLoop, ContinueLoop): pass return if data.error: raise DataError(data.error) limit = WhileLimit.create(data.limit, self._context.variables) errors = [] while self._should_run(data.condition, self._context.variables) \ and limit.is_valid: executed_once = True try: with limit: self._run_iteration(data, result, run) except BreakLoop: break except ContinueLoop: continue except ExecutionFailed as err: errors.extend(err.get_errors()) if not err.can_continue(self._context, self._templated): break if not executed_once: status.pass_status = result.NOT_RUN self._run_iteration(data, result, run=False) if errors: raise ExecutionFailures(errors) if not limit.is_valid: raise DataError(limit.reason)
def run(self, context): errors = [] for kw in self._keywords: try: kw.run(context) except ExecutionPassed, exception: exception.set_earlier_failures(errors) raise exception except ExecutionFailed, exception: errors.extend(exception.get_errors()) if not exception.can_continue( context.in_teardown, self._templated, context.dry_run): break if errors: raise ExecutionFailures(errors) def __nonzero__(self): return bool(self._keywords) def __iter__(self): return iter(self._keywords) class _BaseKeyword: def __init__(self, name='', args=None, doc='', timeout='', type='kw'): self.name = name self.args = args or [] self.doc = doc self.timeout = timeout self.type = type