List of errored tasks.
979534
def errored_tasks(self):
        """"""
        etasks = []
        for status in [self.S_ERROR, self.S_QCRITICAL, self.S_ABICRITICAL]:
            etasks.extend(list(self.iflat_tasks(status=status)))

        return set(etasks)
136548
def get_errors(self):
        
        return [{cr.component_name: cr.get_error()}
                for cr in self.component_results if cr.has_error()]
1338579
def build_system_error(cls, errors=None):
        """"""
        errors = [errors] if not isinstance(errors, list) else errors
        return cls(Status.SYSTEM_ERROR, errors)
162755
def task(name, deps = None, fn = None):
	""""""
	if callable(deps):
		fn = deps
		deps = None

	if not deps and not fn:
		logger.log(logger.red("The task '%s' is empty" % name))
	else:
		tasks[name] = [fn, deps]
909705
def mark_parent_tasks_as_failed(self, task_name, flush_logs=False):
        
        for existing_task_name in self.tasks:
            if existing_task_name == task_name:
                break

            if flush_logs:
                self.tasks[existing_task_name].clear()

            self.tasks[existing_task_name].failed = True

        self.mark_main_tasks_as_failed()
1057381
def failures():
    """"""
    if not HAVE_BIN_LIBS:
        click.echo("missing required binary libs (lz4, msgpack)")
        return

    q = Queue('failed', connection=worker.connection)
    for i in q.get_job_ids():
        j = q.job_class.fetch(i, connection=q.connection)
        click.echo("%s on %s" % (j.func_name, j.origin))
        if not j.func_name.endswith('process_keyset'):
            click.echo("params %s %s" % (j._args, j._kwargs))
        click.echo(j.exc_info)
728245
def error_codes(self):
        """"""
        if self._error_codes is None:
            from .tcex_error_codes import TcExErrorCodes

            self._error_codes = TcExErrorCodes()
        return self._error_codes
444623
public List<Throwable> getErrors() {
        final List<Throwable> retval = new ArrayList<Throwable>();
        for (final TestInfo testInfo : contractTestMap.listTestInfo()) {
            retval.addAll( testInfo.getErrors() );
        }
        return retval;
    }
1365423
def show_tricky_tasks(self, verbose=0):
        
        nids, tasks = [], []
        for task in self.iflat_tasks():
            if task.num_launches > 1 or any(n > 0 for n in (task.num_restarts, task.num_corrections)):
                nids.append(task.node_id)
                tasks.append(task)

        if not nids:
            cprint("Everything's fine, no tricky tasks found", color="green")
        else:
            self.show_status(nids=nids)
            if not verbose:
                print("Use --verbose to print task history.")
                return

            for nid, task in zip(nids, tasks):
                cprint(repr(task), **task.status.color_opts)
                self.show_history(nids=[nid], full_history=False, metadata=False)
                #if task.num_restarts:
                #    self.show_restarts(nids=[nid])
                if task.num_corrections:
                    self.show_corrections(nids=[nid])
469579
private void printErrors(final List<String> filteredDoc,
      final List<String> filteredRefs, final List<String> filteredPreds) {
    this.printStream.println("Errors: {");
    this.printStream.println("Tok: Ref | Pred");
    this.printStream.println("---------------");
    for (int i = 0; i < filteredDoc.size(); i++) {
      this.printStream.println(filteredDoc.get(i) + ": " + filteredRefs.get(i)
          + " | " + filteredPreds.get(i));
    }
    this.printStream.println("}\n");
  }
859737
def execution_errors(self):
        
        if self.split_actions:
            # throttling split this action, get errors from the split
            return [dict(e) for s in self.split_actions for e in s.errors]
        else:
            return [dict(e) for e in self.errors]
784014
def security_errors(self):
        """"""
        errors = ErrorDict()
        for f in ["honeypot", "timestamp", "security_hash"]:
            if f in self.errors:
                errors[f] = self.errors[f]
        return errors
466638
def handle_error(self):
        
        if not self.tasks:
            return

        # All the parents inherit the failure
        self.mark_parent_tasks_as_failed(
            self.cur_task,
            flush_logs=True,
        )

        # Show the start headers for all the parent tasks if they were not
        # shown by the depth level limit
        for index, task in enumerate(self.tasks.values()):
            if self.should_show_by_depth(index + 1):
                continue

            start_task_header = logging.LogRecord(
                '', logging.INFO, '', 0, '', [], None
            )
            start_task_header.msg = ColorFormatter.colored(
                'default',
                START_TASK_MSG,
            )
            start_task_header.task = task.name
            self.pretty_emit(
                start_task_header,
                is_header=True,
                task_level=index + 1,
            )

        # Show now all the cached logs for the current task
        for old_record in self.tasks[self.cur_task]:
            self.pretty_emit(old_record)

        self.tasks[self.cur_task].clear()
719109
def _export_work_errors(self, work, output_file):
    
    errors = set()
    for v in itervalues(work.work):
      if v['is_completed'] and v['error'] is not None:
        errors.add(v['error'])
    with open(output_file, 'w') as f:
      for e in sorted(errors):
        f.write(e)
        f.write('\n')
1256061
def _get_errors(self):
        
        errors = self.json.get('data').get('failures')
        if errors:
            logger.error(errors)
        return errors
1063280
def _subtask_error(self, idx, error):
        """"""
        self.set_exception(error)
        self.errbacks.clear()
760995
function showLoadingErrors() {
  const failedTasks = []
  const taskStatus = {}

  // Construct data for full report
  for (const data of scripts) {
    const messages = []
    // check sources
    const mSources = data.sources.filter(s => glob.sync(s).length === 0)
    if (mSources.length !== 0) {
      messages.push(
        `✘ Missing sources: ${(mSources.length > 1 ? '\n  ' : '') +
          mSources.map(s => `'${s}'`).join('\n  ')}`
      )
    }
    // display remaining errors
    for (const error of data.errors) {
      let msg = error.message || error.toString()
      const prefix = msg.startsWith('Error') ? '' : 'Error: '
      messages.push(`✘ ${prefix}${msg.replace(/\n/g, '\n  ')}`)
    }
    if (messages.length > 0) {
      failedTasks.push(data.name)
    } else {
      messages.push(`✔ No issues detected`)
    }
    taskStatus[data.name] = messages
  }

  if (failedTasks.length !== 0) {
    const messages = []
    for (const key of Object.keys(taskStatus)) {
      messages.push(
        `${key}:\n  ${taskStatus[key].join('\n').replace(/\n/g, '\n  ')}`
      )
    }

    showError(
      new Error(
        `${failedTasks.length > 1 ? 'Errors' : 'Error'} in ${failedTasks
          .map(s => `'${s}'`)
          .join(', ')}\n${messages.join('\n')}`
      )
    )
  }
}