while (!rdmaConnection.canSend() && System.currentTimeMillis() < deadline) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }
        
        if (!rdmaConnection.canSend()) {

    /**
     * Check if connection can send data (has send credits and is established)
     *
     * @return true if can send, false otherwise
     */
    public boolean canSend() {
        return sendCredits.get() > 0 && state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Consume a send credit
     */
    public void consumeSendCredit() {

import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CallEnd
import okhttp3.CallEvent.CallFailed
import okhttp3.CallEvent.CallStart
import okhttp3.CallEvent.ConnectStart
import okhttp3.CallEvent.ConnectionAcquired
import okhttp3.CallEvent.DnsEnd
import okhttp3.CallEvent.DnsStart

            // Given
            when(mockResource.canRead()).thenReturn(true);
            when(mockResource.canWrite()).thenReturn(false);

            // When
            boolean canRead = mockResource.canRead();
            boolean canWrite = mockResource.canWrite();

            // Then
            assertTrue(canRead, "Should be readable");
            assertFalse(canWrite, "Should not be writable");

- Configure etcd - [Etcd V3 Quickstart Guide](https://github.com/minio/minio/blob/master/docs/sts/etcd.md)

### 2. Create a new user with canned policy

01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyEnd: byteCount=128
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] connectionReleased
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] callEnd
01-01 12:53:32.816 10999 11090 D OkHttp  : [54 ms] responseHeadersStart

      .assertLogMatch(Regex("""responseBodyStart"""))
      .assertLogMatch(Regex("""responseBodyEnd: byteCount=6"""))
      .assertLogMatch(Regex("""connectionReleased"""))
      .assertLogMatch(Regex("""callEnd"""))
      .assertNoMoreLogs()
  }

  @Test
  fun post() {
    assumeNotWindows()
    server.enqueue(MockResponse())
    client.newCall(request().post("Hello!".toRequestBody(PLAIN)).build()).execute()

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

  @Test
  fun upgradeForbiddenOnHttp2() {
    enableTls(Protocol.HTTP_2, Protocol.HTTP_1_1)
    val socketHandler = MockSocketHandler()
    server.enqueue(socketHandler.upgradeResponse())

| Params        | Value                                          |
| :--           | :--                                            |

Use [`mc admin policy`](https://docs.min.io/community/minio-object-store/reference/minio-mc-admin/mc-admin-policy.html#command-mc.admin.policy) to create custom admin policies.

Create new canned policy file `adminManageUser.json`. This policy enables admin user to
manage other users.

```json
cat > adminManageUser.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [