@Throws(IOException::class)
  fun peekTrailers(): Headers?

  /**
   * Cancel this stream. Resources held by this stream will be cleaned up, though not synchronously.
   * That may happen later by the connection pool thread.
   */
  fun cancel()

  /**
   * Carries an exchange. This is usually a connection, but it could also be a connect plan for

	m[policy] = p
	return nil
}

func (ies *IAMEtcdStore) loadPolicyDocs(ctx context.Context, m map[string]PolicyDoc) error {
	ctx, cancel := context.WithTimeout(ctx, defaultContextTimeout)
	defer cancel()
	//  Retrieve all keys and values to avoid too many calls to etcd in case of
	//  a large number of policies
	r, err := ies.client.Get(ctx, iamConfigPoliciesPrefix, etcd.WithPrefix())

`mc admin decommission cancel` without an argument, lists out any on-going decommission in progress.

```
λ mc admin decommission cancel alias/
┌─────┬─────────────────────────────────┬──────────────────────────────────┬──────────┐

//
//	e.g. Send the log to a http server
type Target interface {
	String() string
	Endpoint() string
	Stats() types.TargetStats
	Init(ctx context.Context) error
	IsOnline(ctx context.Context) bool
	Cancel()
	Send(ctx context.Context, entry any) error
	Type() types.TargetType
}

type targetsList struct {
	list []Target
	mu   sync.RWMutex
}

func newTargetsList() *targetsList {
	return &targetsList{}

  @Throws(IOException::class)
  internal fun cancelStreamIfNecessary() {
    assertLockNotHeld()

    val open: Boolean
    val cancel: Boolean
    withLock {
      cancel = !source.finished && source.closed && (sink.finished || sink.closed)
      open = isOpen
    }
    if (cancel) {
      // RST this stream to prevent additional data from being sent. This is safe because the input

      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()
  }

  override fun close() {
    javaNetSocket.close()
  }

  fun awaitClosed() {
    closedLatch.await()
  }

	go c.readStream(ctx, conn, cancel)
	c.writeStream(ctx, conn, cancel)
}

// readStream handles the read side of the connection.
// It will read messages and send them to c.handleMsg.
// If an error occurs the cancel function will be called and conn be closed.
// The function will block until the connection is closed or an error occurs.
func (c *Connection) readStream(ctx context.Context, conn net.Conn, cancel context.CancelCauseFunc) {

  fun noNewExchangesOnConnection() {
    codec.carrier.noNewExchanges()
  }

  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,

          .body("abc")
          .build(),
      )

      val call = client.newCall(request)

      assertFailsWith<IOException> {
        call.executeAsync().use {
          call.cancel()
          withContext(Dispatchers.IO) {
            it.body.string()
          }
        }
      }

      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test

	ctx := m.ctx

	// Add deadline if none.
	if msg.DeadlineMS == 0 {
		msg.DeadlineMS = uint32(defaultSingleRequestTimeout / time.Millisecond)
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, defaultSingleRequestTimeout)
		defer cancel()
	}
	// Send request
	if err := m.send(msg); err != nil {
		return nil, err
	}
	if debugReqs {
		fmt.Println(m.MuxID, m.parent.String(), "SEND")
	}