r := RemoteErr(err.Error())
			return nil, &r
		}
		return payload, nil
	}, subroute...)
}

// Requester is able to send requests to a remote.
type Requester interface {
	Request(ctx context.Context, h HandlerID, req []byte) ([]byte, error)
}

// Call the remote with the request and return the response.
// The response should be returned with PutResponse when no error.

We will have two triggers for sending config - requests and pushes.

#### Requests

Requests come from the client specifically asking for a set of resources. This could be requesting the initial set of resources on a new connection, or from a new dependency. For example, a push of `Cluster X` referencing `Endpoint Y` may lead to a request for `Endpoint Y` if it is not already known to the client.

	m.singleResp = false
	m.RecvSeq = m.SendSeq // Sync
	if cap(requests) > 0 {
		m.outBlock = make(chan struct{}, cap(requests))
	}
	msg := message{
		Op:         OpConnectMux,
		Handler:    h,
		Payload:    payload,
		DeadlineMS: uint32(m.deadline.Milliseconds()),
	}
	msg.setZeroPayloadFlag()
	if requests == nil {
		msg.Flags |= FlagEOF
	}
	if m.subroute != nil {

   * the inbound request was truncated, this exception will be non-null.
   */
  val failure: IOException? = null,
) {
  val method: String?
  val path: String?

  /**
   * The TLS handshake of the connection that carried this request, or null if the request was
   * received without TLS.
   */
  val handshake: Handshake?
  val requestUrl: HttpUrl?

  /**

    }

    internal constructor(request: Request) {
      this.url = request.url
      this.method = request.method
      this.body = request.body
      this.tags =
        when {
          request.tags.isEmpty() -> mapOf()
          else -> request.tags.toMutableMap()
        }
      this.headers = request.headers.newBuilder()
      this.cacheUrlOverride = request.cacheUrlOverride
    }

        .cache(cache)
        .build()
    val request1 = Request(server.url("/"))
    client.newCall(request1).enqueue(callback)
    callback.await(request1.url).assertCode(200).assertBody("A")
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()
    val request2 = Request(server.url("/"))
    client.newCall(request2).enqueue(callback)
    callback.await(request2.url).assertCode(200).assertBody("A")

  // Optional: confirm that your app made the HTTP requests you were expecting.
  RecordedRequest request1 = server.takeRequest();
  assertEquals("/v1/chat/messages/", request1.getPath());
  assertNotNull(request1.getHeader("Authorization"));

  RecordedRequest request2 = server.takeRequest();
  assertEquals("/v1/chat/messages/2", request2.getPath());

  RecordedRequest request3 = server.takeRequest();

	if f.Logger != nil && err != context.Canceled {
		f.Logger(err)
	}
	w.WriteHeader(http.StatusBadGateway)
}

func (f *Forwarder) getURLFromRequest(req *http.Request) *url.URL {
	// If the Request was created by Go via a real HTTP request,  RequestURI will
	// contain the original query string. If the Request was created in code, RequestURI

  private fun assertConnectionReused(vararg requests: Request?) {
    for (i in requests.indices) {
      val response = client.newCall(requests[i]!!).execute()
      response.body.string() // Discard the response body.
      assertThat(server.takeRequest().sequenceNumber).isEqualTo(i)
    }
  }

  private fun assertConnectionNotReused(vararg requests: Request?) {
    for (request in requests) {

  @Test
  fun executionRejectedAfterMaxRequestsChange() {
    val request1 = newRequest("http://a/1")
    val request2 = newRequest("http://a/2")
    dispatcher.maxRequests = 1
    client.newCall(request1).enqueue(callback)
    executor.shutdown()
    client.newCall(request2).enqueue(callback)
    dispatcher.maxRequests = 2 // Trigger promotion.
    callback.await(request2.url).assertFailure(InterruptedIOException::class.java)