* @param consumer the consumer to execute
         */
        public void godHandEpilogue(final ActionRuntime runtime, final Consumer<ActionRuntime> consumer) {
            consumer.accept(runtime);
        }

        /**
         * Before hook for action processing.
         *
         * @param runtime the action runtime
         * @param func the function to execute

      - [ThirdPartyResource](#thirdpartyresource)
      - [kubectl](#kubectl)
      - [kubernetes Core Known Issues](#kubernetes-core-known-issues)
      - [Docker runtime Known Issues](#docker-runtime-known-issues)
      - [Rkt runtime Known Issues](#rkt-runtime-known-issues)
  - [Provider-specific Notes](#provider-specific-notes)
  - [Previous Releases Included in v1.3.0](#previous-releases-included-in-v130)
- [v1.3.0-beta.3](#v130-beta3)

            return num;
        }
        return Runtime.getRuntime().availableProcessors();
    }

    Integer getCrawlerHttpThreadPoolSizeAsInteger();

    default int getCrawlerHttpProcessors() {
        final int num = getCrawlerHttpThreadPoolSizeAsInteger();
        if (num > 0) {
            return num;
        }
        return Runtime.getRuntime().availableProcessors();
    }

  private Futures() {}

  /**
   * Creates a {@code ListenableFuture} which has its value set immediately upon construction. The
   * getters just return the value. This {@code Future} can't be canceled or timed out and its
   * {@code isDone()} method always returns {@code true}.
   */
  public static <V extends @Nullable Object> ListenableFuture<V> immediateFuture(
      @ParametricNullness V value) {
    if (value == null) {

          .url(server.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isIn("timeout", "Read timed out")
    }
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",
      "ConnectStart",

   *
   * <p><b>Warning:</b> after invoking this method, do not continue to use <i>this</i> cache builder
   * reference; instead use the reference this method <i>returns</i>. At runtime, these point to the
   * same instance, but only the returned reference has the correct generic type information to
   * ensure type safety. For best results, use the standard method-chaining idiom illustrated in the

			<artifactId>lasta-taglib</artifactId>
			<version>${lasta.taglib.version}</version>
		</dependency>

		<!-- dbflute -->
		<dependency>
			<groupId>org.dbflute</groupId>
			<artifactId>dbflute-runtime</artifactId>
			<version>${dbflute.version}</version>
		</dependency>

		<!-- J2EE -->
		<dependency>
			<groupId>jakarta.servlet.jsp.jstl</groupId>
			<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>

       * errorMessageTemplate parameters: It is unlikely that callers intend for their string
       * template to be null (though we do handle that case gracefully at runtime). I've left this
       * one as it is because one of our users has defined a wrapper API around Preconditions,
       * declaring a checkState method that accepts a possibly null template. So we'd need to update