*
     * @return the execution time in milliseconds
     */
    public long getExecutionTime() {
        return executionTime;
    }

    /**
     * Sets the execution time for processing this response.
     *
     * @param executionTime the execution time in milliseconds
     */
    public void setExecutionTime(final long executionTime) {

    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse()
        .setBody(Buffer().write(ByteArray(responseBodySize)))
        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

 */
package okhttp3.internal.cache

import java.io.IOException
import java.net.HttpURLConnection.HTTP_GATEWAY_TIMEOUT
import java.net.HttpURLConnection.HTTP_NOT_MODIFIED
import java.util.concurrent.TimeUnit.MILLISECONDS
import okhttp3.Cache
import okhttp3.EventListener
import okhttp3.Headers
import okhttp3.Interceptor
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.internal.closeQuietly

        final long finalCleanupInterval = cleanupInterval;
        this.cleanupExecutor.scheduleWithFixedDelay(() -> cleanupExpiredLeases(finalCleanupInterval * 2), cleanupInterval, cleanupInterval,
                TimeUnit.MILLISECONDS);
    }

    /**
     * Lease entry containing lease state information
     */
    public static class LeaseEntry {
        private final Smb2LeaseKey leaseKey;
        private volatile int leaseState;

 *   <li>secretKey - The secret key for authentication</li>
 *   <li>connectTimeout - Connection timeout in milliseconds (default: 10000)</li>
 *   <li>writeTimeout - Write timeout in milliseconds (default: 10000)</li>
 *   <li>readTimeout - Read timeout in milliseconds (default: 10000)</li>
 * </ul>
 *
 * <p>The client supports URLs in the format: {@code storage://bucket-name/object-path}
 *
 * <p>Features:

    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /** The interval time between crawl requests in milliseconds (required, 0 to 2147483647). */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer intervalTime;

    public static final String DEFAULT_HOURLY_CRON_EXPRESSION = "0 * * * *";

    /** Default interval time in milliseconds for file system crawling. */
    public static final int DEFAULT_INTERVAL_TIME_FOR_FS = 1000;

    /** Default interval time in milliseconds for web crawling. */
    public static final int DEFAULT_INTERVAL_TIME_FOR_WEB = 10000;

   *
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.
   * @param elapsedMs the time in milliseconds elapsed since the immediately-preceding event, or
   *     -1L to take any duration.
   */
  fun takeEvent(
    eventClass: Class<out ConnectionEvent>? = null,
    elapsedMs: Long = -1L,
  ): ConnectionEvent {

 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,
  private val taskRunner: TaskRunner,
) : ExchangeFinder {
  private val connectDelayNanos = TimeUnit.MILLISECONDS.toNanos(250L)
  private var nextTcpConnectAtNanos = Long.MIN_VALUE

  /**
   * Plans currently being connected, and that will later be added to [connectResults]. This is

    @Resource
    protected IndexingHelper indexingHelper;

    /** Flag indicating if crawling should be finished */
    protected boolean finishCrawling = false;

    /** Total execution time in milliseconds */
    protected long executeTime;

    /** Total number of processed documents */
    protected long documentSize;

    /** Maximum number of indexer errors allowed */