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

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

        .build(),
    )
    listener.enqueueCancel() // Will cancel in onOpen().
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    processResponse(response, listener)
    listener.assertOpen()
    listener.assertFailure("canceled")
  }

@ExperimentalCoroutinesApi // resume with a resource cleanup.
suspend fun Call.executeAsync(): Response =
  suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      this.cancel()
    }
    this.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

  override fun request(): Request = error("unexpected")

  override fun execute(): Response = error("unexpected")

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")

  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(this, requestDone = true, responseDone = true, e = null)
  }

   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new web socket and immediately returns it. Creating a web socket initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must either close or cancel the returned web socket when it is no longer
     * in use.

  @Throws(IOException::class)
  internal fun cancelStreamIfNecessary() {
    lock.assertNotHeld()

    val open: Boolean
    val cancel: Boolean
    this.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

    streamId: Int,
    source: BufferedSource,
    byteCount: Int,
    last: Boolean,
  ): Boolean

  /** Indicates the reason why this stream was canceled. */
  fun onReset(
    streamId: Int,
    errorCode: ErrorCode,
  )

  companion object {
    @JvmField val CANCEL: PushObserver = PushObserverCancel()

    private class PushObserverCancel : PushObserver {
      override fun onRequest(
        streamId: Int,

    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")

    delegate.callFailed(call, ioe)
  }

  override fun canceled(call: Call) {
    logWithTime("canceled")

    delegate.canceled(call)
  }

  override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) {
    logWithTime("satisfactionFailure")

    apply {
      actions += { stream ->
        if (!stream.requestBody.exhausted()) throw AssertionError("expected exhausted")
      }
    }

  fun cancelStream() =
    apply {
      actions += { stream -> stream.cancel() }
    }

  fun requestIOException() =
    apply {
      actions += { stream ->
        try {
          stream.requestBody.exhausted()
          throw AssertionError("expected IOException")