fun cancel()

  /**
   * Returns true if this call has been either [executed][execute] or [enqueued][enqueue]. It is an
   * error to execute a call more than once.
   */
  fun isExecuted(): Boolean

  fun isCanceled(): Boolean

  /**
   * Returns a timeout that spans the entire call: resolving DNS, connecting, writing the request
   * body, server processing, and reading the response body. If the call requires redirects or

  override fun find(): RealConnection {
    var firstException: IOException? = null
    try {
      while (tcpConnectsInFlight.isNotEmpty() || routePlanner.hasNext()) {
        if (routePlanner.isCanceled()) throw IOException("Canceled")

        // Launch a new connection if we're ready to.
        val now = taskRunner.backend.nanoTime()
        var awaitTimeoutNanos = nextTcpConnectAtNanos - now

 * thread executing the call.
 */
interface RoutePlanner {
  val address: Address

  /** Follow-ups for failed plans and plans that lost a race. */
  val deferredPlans: ArrayDeque<Plan>

  fun isCanceled(): Boolean

  /** Returns a plan to attempt. */
  @Throws(IOException::class)
  fun plan(): Plan

  /**
   * Returns true if there's more route plans to try.
   *

     * @return 永続的かどうか
     */
    public boolean isPermanent() {
        return permanent;
    }

    /**
     * キャンセルされているかどうかを返します。
     *
     * @return キャンセルされているか
     */
    public boolean isCanceled() {
        return status == CANCELED;
    }

    /**
     * キャンセルします。
     */
    public void cancel() {
        status = CANCELED;
    }

    /**
     * 止まっているかどうか返します。
     *

            throw new ExtractException(e);
        } finally {
            if (accessTimeout != null) {
                accessTimeoutTarget.stop();
                if (!accessTimeoutTask.isCanceled()) {
                    accessTimeoutTask.cancel();
                }
            }
        }
        return data;
    }

    public void setUrl(final String url) {
        this.url = url;

    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        val call = chain.call()
        callRef.set(call)
        assertThat(call.isCanceled()).isFalse()
        call.cancel()
        assertThat(call.isCanceled()).isTrue()
        chain.proceed(chain.request())
      }
    client =
      client.newBuilder()
        .addInterceptor(interceptor)
        .build()

            logger.warn("Failed to run python command.", e);
            resultBuf.append(e.getMessage()).append("\n");
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

    }

    protected void executePython() {

            return getResponseData(uri, includeContent);
        } finally {
            if (accessTimeoutTarget != null) {
                accessTimeoutTarget.stop();
                if (!accessTimeoutTask.isCanceled()) {
                    accessTimeoutTask.cancel();
                }
            }
        }
    }

    protected ResponseData getResponseData(final String uri, final boolean includeContent) {

  override val address = factory.newAddress("example.com")

  fun addPlan(): FakePlan {
    return FakePlan(nextPlanId++).also {
      plans += it
    }
  }

  override fun isCanceled() = canceled

  override fun plan(): FakePlan {
    // Return deferred plans preferentially. These don't require addPlan().
    if (deferredPlans.isNotEmpty()) return deferredPlans.removeFirst() as FakePlan

    while (true) {
      call.enterNetworkInterceptorExchange(request, newRoutePlanner, chain)

      var response: Response
      var closeActiveExchange = true
      try {
        if (call.isCanceled()) {
          throw IOException("Canceled")
        }

        try {
          response = realChain.proceed(request)
          newRoutePlanner = true
        } catch (e: IOException) {