*     new FutureCallback<QueryResult>() {
   *       public void onSuccess(QueryResult result) {
   *         storeInCache(result);
   *       }
   *       public void onFailure(Throwable t) {
   *         reportError(t);
   *       }
   *     }, executor);
   * }
   *
   * <p>When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See

        "Coordination service is not enabled.");
    return;
  }
  absl::Status s(static_cast<absl::StatusCode>(error_code), error_message);
  status->status = coord_agent->ReportError(s);
}

void TFE_GetTaskStates(TFE_Context* ctx, const TF_Buffer& tasks, void* states,
                       TF_Status* status) {
  tensorflow::ImmediateExecutionDistributedManager* dist_mgr =

   *     new FutureCallback<QueryResult>() {
   *       public void onSuccess(QueryResult result) {
   *         storeInCache(result);
   *       }
   *       public void onFailure(Throwable t) {
   *         reportError(t);
   *       }
   *     }, e);
   * }
   *
   * <p>When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See

            gatherDeadLinksInFile(file, errors);
        });

        reportErrors(errors, getReportFile().get().getAsFile());
    }

    private void reportErrors(Map<File, List<Error>> errors, File reportFile) {
        try (PrintWriter fw = new PrintWriter(new FileWriter(reportFile))) {
            writeHeader(fw);

	logger.CriticalIf(GlobalContext, registry.Register(nodeCollector))
	if err := registry.Register(prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{
		Namespace:    minioNamespace,
		ReportErrors: true,
	})); err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	if err := registry.Register(prometheus.NewGoCollector()); err != nil {
		logger.CriticalIf(GlobalContext, err)
	}