return c.call(ctx, lockRPCRLock, &args)
}

// Lock calls lock REST API.
func (c *lockRESTClient) Lock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCLock, &args)
}

// RUnlock calls read unlock REST API.
func (c *lockRESTClient) RUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {

    }

    /**
     * Prompts the user for a string using a list of possible values and a default reply.
     *
     * @param message the message to display
     * @param possibleValues the list of possible values
     * @param defaultReply the default reply value
     * @return the string entered by the user
     * @throws PrompterException if an exception occurs
     */
    @Nonnull

    scheme: HTTP
  initialDelaySeconds: 120
  periodSeconds: 15
  timeoutSeconds: 10
  successThreshold: 1
  failureThreshold: 3
```

## Cluster probe

### Cluster-writeable probe

The reply is '200 OK' if cluster has write quorum if not it returns '503 Service Unavailable'.

```
curl http://minio1:9001/minio/health/cluster
HTTP/1.1 503 Service Unavailable
Accept-Ranges: bytes
Content-Length: 0

issue (DoS, authentication bypass, information disclose, ...) and the assumptions you're making (e.g. do
you need access credentials for a successful exploit).

If you have not received a reply to your email within 48 hours or you have not heard from the security team
for the past five days please contact the security team directly:

- Primary security coordinator: ******@****.***
- Secondary coordinator: ******@****.***

    int readDataWireFormat( byte[] buffer, int bufferIndex, int len ) {
        int start = bufferIndex;

        pathConsumed = readInt2( buffer, bufferIndex );
        bufferIndex += 2;
            /* Samba 2.2.8a will reply with Unicode paths even though
             * ASCII is negotiated so we must use flags2 (probably
             * should anyway).
             */
        if((flags2 & FLAGS2_UNICODE) != 0) {
            pathConsumed /= 2;

        throw errorException ?: StreamResetException(errorCode!!)
      }
      throw IllegalStateException("too early; can't read the trailers yet")
    }
  }

  /**
   * Sends a reply to an incoming stream.
   *
   * @param outFinished true to eagerly finish the output stream to send data to the remote peer.
   *     Corresponds to `FLAG_FIN`.

	return restClient.Call("/v1/refresh", args)
}

func (restClient *ReconnectRESTClient) ForceUnlock(ctx context.Context, args LockArgs) (reply bool, err error) {
	return restClient.Call("/v1/force-unlock", args)
}

func (restClient *ReconnectRESTClient) String() string {
	return restClient.u.String()

      } catch (e: IOException) {
        failConnection(e)
      }
    }
  }

  fun writePing(
    reply: Boolean,
    payload1: Int,
    payload2: Int,
  ) {
    try {
      writer.ping(reply, payload1, payload2)
    } catch (e: IOException) {
      failConnection(e)
    }
  }

  /** For testing: sends a ping and waits for a pong. */

			if err != nil {
				t.Error(err)
				return
			}
			gotS := strings.TrimSpace(string(got))
			if !reflect.DeepEqual(gotS, testCase.wantResult) {
				t.Errorf("received response does not match with expected reply. Query: %s\ngot: %s\nwant:%s", testCase.query, gotS, testCase.wantResult)
			}
		})
		t.Run("simd-"+testCase.name, func(t *testing.T) {
			if !simdjson.SupportedCPU() {
				t.Skip("No CPU support")
			}

    protected static final String AZUREAD_CLIENT_SECRET = "aad.client.secret";

    protected static final String AZUREAD_CLIENT_ID = "aad.client.id";

    protected static final String AZUREAD_REPLY_URL = "aad.reply.url";

    protected static final String STATES = "aadStates";

    protected static final String STATE = "state";

    protected static final String ERROR = "error";