truncated response from an HTTPS proxy.


## Version 3.14.1

_2019-04-10_

 *  Fix: Don't crash when an interceptor retries when there are no more routes. This was an
    edge-case regression introduced with the events cleanup in 3.14.0.

 *  Fix: Provide actionable advice when the exchange is non-null. Prior to 3.14, OkHttp would

    assertThat(response.body.string()).isEqualTo("abc")
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    // Note that although we have two routes available, we only use one. The retry is permitted
    // because there are routes available, but it chooses the existing connection since it isn't
    // yet considered unhealthy.
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
  }

    planToReplace: ConnectPlan? = null,
    routes: List<Route>? = null,
  ): ReusePlan? {
    val result =
      connectionPool.callAcquirePooledConnection(
        doExtensiveHealthChecks = connectionUser.doExtensiveHealthChecks(),
        address = address,
        connectionUser = connectionUser,
        routes = routes,
        requireMultiplexed = planToReplace != null && planToReplace.isReady,

 *     a race in fast follow-up.
 *
 *  4. If there's no existing connection, make a list of routes (which may require blocking DNS
 *     lookups) and attempt a new connection them. When failures occur, retries iterate the list of
 *     available routes.
 *
 * If the pool gains an eligible connection while DNS, TCP, or TLS work is in flight, this finder

    server.enqueue(MockResponse(socketPolicy = DisconnectAtStart))
    server.enqueue(MockResponse(socketPolicy = DisconnectAtStart))

    client =
      client.newBuilder()
        .dns(DoubleInetAddressDns()) // Two routes so we get two failures.
        .build()

    val request = Request(server.url("/"))
    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->

    if (requestSendStarted && requestIsOneShot(e, userRequest)) return false

    // This exception is fatal.
    if (!isRecoverable(e, requestSendStarted)) return false

    // No more routes to attempt.
    if (!call.retryAfterFailure()) return false

    // For failure recovery, use the same route selector with a new connection.
    return true
  }

  private fun requestIsOneShot(

    misleading; it was always used to configure redirects between `https://` and
    `http://` schemes.

 *  **RouteDatabase is no longer public API.** OkHttp continues to track which
    routes have failed but this is no exposed in the API.

 *  **ResponseSource is gone.** This enum exposed whether a response came from
    the cache, network, or both. OkHttp 2 offers more detail with raw access to

  val responses = mutableListOf<Response>()
  val routes = mutableListOf<Route>()

  fun onlyResponse() = responses.single()

  fun onlyRoute() = routes.single()

  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    if (route == null) throw NullPointerException("route == null")
    responses += response
    routes += route

package okhttp3.internal.connection

import okhttp3.Route

/**
 * A denylist of failed routes to avoid when creating a new connection to a target address. This is
 * used so that OkHttp can learn from its mistakes: if there was a failure attempting to connect to
 * a specific IP address or proxy server, that failure is remembered and alternate routes are
 * preferred.
 */
class RouteDatabase {
  private val _failedRoutes = mutableSetOf<Route>()

   *
   * If [routes] is non-null these are the resolved routes (ie. IP addresses) for the connection.
   * This is used to coalesce related domains to the same HTTP/2 connection, such as `square.com`
   * and `square.ca`.
   */
  fun callAcquirePooledConnection(
    doExtensiveHealthChecks: Boolean,
    address: Address,
    connectionUser: ConnectionUser,
    routes: List<Route>?,