val elapsedNs = queue.taskRunner.backend.nanoTime() - startNs
      if (completedNormally) {
        log(task, queue, "finished run in ${formatDuration(elapsedNs)}")
      } else {
        log(task, queue, "failed a run in ${formatDuration(elapsedNs)}")
      }
    }
  }
}

private fun Logger.log(
  task: Task,
  queue: TaskQueue,
  message: String,
) {

                }
                length = bis.read(bytes);
            }
            return baos.toString(encoding);
        } catch (final Exception e) {
            throw new CurlException("Failed to access the content.", e);
        }
    }

    public InputStream getContentAsStream() throws IOException {
        if (contentCache == null) {
            if (contentException != null) {

		Name: constants.ValidationContainerName,
		State: corev1.ContainerState{
			Waiting: &corev1.ContainerStateWaiting{
				Reason:  "CrashLoopBackOff",
				Message: "Back-off 5m0s restarting failed blah blah blah",
			},
		},
		LastTerminationState: corev1.ContainerState{
			Terminated: &corev1.ContainerStateTerminated{
				ExitCode: constants.ValidationErrorCode,
				Reason:   "Error",

        try {
            return CommonsCliMavenOptions.parse(source, args.toArray(new String[0]));
        } catch (ParseException e) {
            throw new ParserException("Failed to parse source " + source, e.getCause());
        }
    }

    // TODO: same is in DefaultMavenParser!!! (duplication)
    @Override
    protected MavenOptions assembleOptions(List<MavenOptions> parsedOptions) {

	cfg.RedirectDNS = rdrct.dnsRedirect
	cfg.CaptureAllDNS = rdrct.dnsRedirect
	cfg.DropInvalid = rdrct.invalidDrop
	cfg.DualStack = rdrct.dualStack

	netNs, err := getNs(netns)
	if err != nil {
		err = fmt.Errorf("failed to open netns %q: %s", netns, err)
		return err
	}
	defer netNs.Close()

	return netNs.Do(func(_ ns.NetNS) error {
		// Important: run within the pod network namespace since some attributes are namespace specific

    public ModelBuilderException(ModelBuilderResult result) {
        super(result.toString());
        this.result = result;
    }

    /**
     * Gets the interim result of the model building up to the point where it failed.
     *
     * @return The interim model building result or {@code null} if not available.
     */
    public ModelBuilderResult getResult() {
        return result;
    }

    /**

        shell: bash
        run: ./mvnw -B -P!standard-with-extra-repos verify -U -Dmaven.javadoc.skip=true -f $ROOT_POM
      - name: 'Print Surefire reports'
        # Note: Normally a step won't run if the job has failed, but this causes it to
        if: ${{ failure() }}
        shell: bash
        run: ./util/print_surefire_reports.sh
      - name: 'Integration Test'
        if: matrix.java == 11
        shell: bash

   * primary input fails with the given {@code exceptionType}, from the result provided by the
   * {@code fallback}. {@link Function#apply} is not invoked until the primary input has failed, so
   * if the primary input succeeds, it is never invoked. If, during the invocation of {@code
   * fallback}, an exception is thrown, this exception is used as the result of the output {@code
   * Future}.
   *

                logError("close", e, eventSpy);
            }
        }
    }

    private void logError(String action, Throwable e, EventSpy spy) {
        String msg = "Failed to " + action + " spy " + spy.getClass().getName() + ": " + e.getMessage();

        if (logger.isDebugEnabled()) {
            logger.warn(msg, e);
        } else {
            logger.warn(msg);
        }

                        return builder.setScript(script);
                    }
                } catch (final Exception e) {
                    logger.warn("Failed to process {}", hit, e);
                }
                return null;
            });
            resultBuf.append(count).append(" docs").append("\n");
        } catch (final Exception e) {