}

  data class CallStart(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CallEnd(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class CallFailed(

    expectedEvents += "FollowUpDecision"
    expectedEvents += "ResponseBodyStart"
    expectedEvents += "ResponseBodyEnd"
    expectedEvents += "ConnectionReleased"
    expectedEvents += "CallEnd"
    assertThat(listener.recordedEventTypes()).isEqualTo(expectedEvents)

    // Confirm that the connection pool was not corrupted by making another call.
    makeSimpleCall()
  }

  /**

      "RequestHeadersEnd",
      "ResponseHeadersStart",
      "ResponseHeadersEnd",
      "FollowUpDecision",
      "ResponseBodyStart",
      "ResponseBodyEnd",
      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun sseReauths() {
    client =
      client
        .newBuilder()
        .authenticator { route, response ->
          response.request
            .newBuilder()

        "ResponseHeadersStart",
        "ResponseHeadersEnd",
        "FollowUpDecision",
        "ResponseBodyStart",
        "ResponseBodyEnd",
        "ConnectionReleased",
        "CallEnd",
      ),
      eventListener.recordedEventTypes(),
    )

    eventListener.clearAllEvents()

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    }

    override fun secureConnectEnd(
      call: Call,
      handshake: Handshake?,
    ) {
      logger.removeHandler(loggerHandler)
    }

    override fun callEnd(call: Call) {
      // Cleanup log handler if failed.
      logger.removeHandler(loggerHandler)
    }

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {

      "ResponseHeadersStart",
      "ResponseHeadersEnd",
      "FollowUpDecision",
      "ResponseBodyStart",
      "ResponseBodyEnd",
      "RequestBodyEnd",
      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun duplexWith100Continue() {
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()
        .receiveRequest("request body\n")

  - SSE (Server Side Encryption)
  - Replication (Server Side Replication)

## Prerequisites

- It is assumed you have users created and configured with relevant access policies, to start with
  use basic "readwrite" canned policy to test all the operations before you finalize on what level
  of restrictions are needed for a user.

- No "admin:*" operations are needed for FTP/SFTP access to the bucket(s) and object(s), so you may

// error returned in IAM subsystem when a group is disabled
var errGroupDisabled = errors.New("Specified group is disabled")

// error returned in IAM subsystem when policy doesn't exist.
var errNoSuchPolicy = errors.New("Specified canned policy does not exist")

// error returned when policy to be deleted is in use.
var errPolicyInUse = errors.New("Specified policy is in use and cannot be deleted.")

| policy     | _string_       | Canned policy name to be applied for STS credentials. (Recommended)                                                                                                                     |

| policy     | _string_ or _[]string_ or _comma_separated_value_ | Canned policy name to be applied for STS credentials. (Mandatory) - This can be configured to any desired value such as `roles` or `groups` by setting the environment variable `MINIO_IDENTITY_OPENID_CLAIM_NAME` |

## Get started