}

  fun cancel() {
    codec.cancel()
  }

  /**
   * Revoke this exchange's access to streams. This is necessary when a follow-up request is
   * required but the preceding exchange hasn't completed yet.
   */
  fun detachWithViolence() {
    codec.cancel()
    call.messageDone(
      exchange = this,
      requestDone = true,
      responseDone = true,
      socketSinkDone = true,

    private void put(TransferEvent event, boolean last) {
        try {
            Exchange exchange;
            if (blockOnLastEvent && last) {
                exchange = new BlockingExchange(event);
            } else {
                exchange = new Exchange(event);
            }
            eventQueue.put(exchange);
            exchange.waitForProcessed();
        } catch (InterruptedException e) {

 */
class RealInterceptorChain(
  internal val call: RealCall,
  private val interceptors: List<Interceptor>,
  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int,
  override val authenticator: Authenticator,
  override val cache: Cache?,

    private void put(TransferEvent event, boolean last) {
        try {
            Exchange exchange;
            if (blockOnLastEvent && last) {
                exchange = new BlockingExchange(event);
            } else {
                exchange = new Exchange(event);
            }
            eventQueue.put(exchange);
            exchange.waitForProcessed();
        } catch (InterruptedException e) {

    exchange: Exchange,
    requestDone: Boolean = false,
    responseDone: Boolean = false,
    socketSourceDone: Boolean = false,
    socketSinkDone: Boolean = false,
    e: IOException?,
  ): IOException? {
    if (exchange != this.exchange) return e // This exchange was detached violently!

    var allStreamsDone = false
    var callDone = false
    withLock {
      if (
        requestDone && requestBodyOpen ||

            .request(request)
            .priorResponse(priorResponse?.stripBody())
            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange, chain)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false

    open fun receivedResponseAtMillis(receivedResponseAtMillis: Long) =
      apply {
        this.receivedResponseAtMillis = receivedResponseAtMillis
      }

    internal fun initExchange(exchange: Exchange) {
      this.exchange = exchange
    }

    open fun build(): Response {
      check(code >= 0) { "code < 0: $code" }
      return Response(
        checkNotNull(request) { "request == null" },

  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.call.initExchange(realChain)
    val connectedChain = realChain.copy(exchange = exchange)
    return connectedChain.proceed(realChain.request)
  }

   * connection index, they also shared a socket connection.
   */
  public val connectionIndex: Int,
  /**
   * The index of this exchange on its HTTP connection. A request is uniquely identified by the
   * (connection index, exchange index) pair.
   */
  public val exchangeIndex: Int,
  /**
   * The TLS handshake of the connection that carried this request, or null if the request was

	"github.com/rabbitmq/amqp091-go"
)

// AMQPArgs - AMQP target arguments.
type AMQPArgs struct {
	Enable            bool        `json:"enable"`
	URL               amqp091.URI `json:"url"`
	Exchange          string      `json:"exchange"`
	RoutingKey        string      `json:"routingKey"`
	ExchangeType      string      `json:"exchangeType"`
	DeliveryMode      uint8       `json:"deliveryMode"`
	Mandatory         bool        `json:"mandatory"`