public Dictionary <string, string> executeOperation(Transport transport)
{
//Defines a new Dictonary which is capable of storing indexed string values with a string index.
Dictionary <string, string> result;
//Writes the request header
HeaderParams param = writeHeader(transport, STATS_REQUEST);
transport.flush();
readHeaderAndValidate(transport, param);
//reads the number of statistic details sent from server
int numberOfStats = transport.readVInt();
if (logger.IsTraceEnabled)
{
logger.Trace("Number of Stats : " + numberOfStats);
}
result = new Dictionary <string, string>();
//reads all statistics and add them to the 'result' dictionary
for (int i = 0; i < numberOfStats; i++)
{
String statName = transport.readString();
if (logger.IsTraceEnabled)
{
logger.Trace("Stat Name Recieved : " + statName);
}
String statValue = transport.readString();
if (logger.IsTraceEnabled)
{
logger.Trace("Stat ValueRecieved : " + statName);
}
result.Add(statName, statValue);
}
return(result);
}
/// <summary>
/// Sends a request which involves only a 'key' (no value) to the server
/// </summary>
/// <param name="key"></param>
/// <param name="transport"></param>
/// <param name="opCode">OPeration Code of the request</param>
/// <param name="opRespCode">Expected response code</param>
/// <returns>Status returned form the server</returns>
protected byte sendKeyOperation(byte[] key, Transport transport, byte opCode, byte opRespCode)
{
// 1) write [header][key length][key]
HeaderParams param = writeHeader(transport, opCode);
transport.writeArray(key);
transport.getBinaryWriter().Flush(); //TODO: Hide Binary Writer here
// 2) now read the header
return(readHeaderAndValidate(transport, param));
}
public void executeOperation(Transport transport)
{
HeaderParams param = writeHeader(transport, CLEAR_REQUEST);
if (logger.IsTraceEnabled)
{
logger.Trace("Clear Request Sent");
}
transport.flush();
readHeaderAndValidate(transport, param);
}
protected RestRequest(HttpMethod method, UrlParams urlParameters, HeaderParams headerParameters, QueryParams queryParameters,
BodyParams bodyParameters, DataParams dataParameters)
{
Method = method;
UrlParameters = urlParameters.ThrowIfNull(nameof(urlParameters)).ToList();
HeaderParameters = headerParameters.ThrowIfNull(nameof(headerParameters)).ToList();
QueryParameters = queryParameters.ThrowIfNull(nameof(queryParameters)).ToList();
BodyParameters = bodyParameters.ThrowIfNull(nameof(bodyParameters))
.Select(p => new FieldRequestData(p.Name, p.Value))
.Concat(dataParameters.ThrowIfNull(nameof(dataParameters)))
.ToList();
}
public VersionedOperationResponse executeOperation(Transport transport)
{
// 1) write header
HeaderParams param = writeHeader(transport, REMOVE_IF_UNMODIFIED_REQUEST);
//2) write message body
transport.writeArray(key);
transport.writeLong(version);
logger.Trace("written : key = " + key + " version = " + version);
transport.flush();
//process response and return
return(returnVersionedOperationResponse(transport, param));
}
protected HeaderParams writeHeader(Transport transport, byte operationCode)
{
HeaderParams param = new HeaderParams().opCode(operationCode).cacheName(cacheName).flags(flags).clientIntel(HotRodConstants.CLIENT_INTELLIGENCE_BASIC).topologyId(topologyId).txMarker(NO_TX);
if (logger.IsTraceEnabled)
{
if (logger.IsTraceEnabled)
{
string msg = ("headerparams created " + operationCode + " " + cacheName + " " + flags + " " + HotRodConstants.CLIENT_INTELLIGENCE_BASIC + " " + topologyId + " " + NO_TX);
logger.Trace(msg);
}
}
return(codec.writeHeader(transport, param, HotRodConstants.VERSION_11));
}
//[header][key length][key][lifespan][max idle][value length][value]
protected byte sendPutOperation(Transport transport, byte opCode, byte opRespCode)
{
// 1) write header
HeaderParams param = writeHeader(transport, opCode);
// 2) write key and value
transport.writeArray(key);
transport.writeVInt(lifespan);
transport.writeVInt(maxIdle);
transport.writeArray(value);
transport.getBinaryWriter().Flush();
// 3) now read header
return(readHeaderAndValidate(transport, param));
}
public Dictionary <byte[], byte[]> executeOperation(Transport transport)
{
HeaderParams param = writeHeader(transport, BULK_GET_REQUEST);
transport.writeVInt(entryCount);
transport.flush();
readHeaderAndValidate(transport, param);
Dictionary <byte[], byte[]> result = new Dictionary <byte[], byte[]>();
while (transport.readByte() == 1)
{
result.Add(transport.readArray(), transport.readArray());
}
return(result);
}
public VersionedOperationResponse executeOperation(Transport transport)
{
// 1) write header
HeaderParams param = writeHeader(transport, REPLACE_IF_UNMODIFIED_REQUEST);
//2) write message body
transport.writeArray(key);
transport.writeVInt(lifespan);
transport.writeVInt(maxIdle);
transport.writeLong(version);
transport.writeArray(value);
logger.Trace("written : key = " + key + " version = " + version + "value = " + value);
transport.flush();
return(returnVersionedOperationResponse(transport, param));
}
public PingResult execute()
{
try
{
HeaderParams param = writeHeader(transport, HotRodConstants.PING_REQUEST);
transport.getBinaryWriter().Flush();
short respStatus = readHeaderAndValidate(transport, param);
if (respStatus == HotRodConstants.NO_ERROR_STATUS)
{
if (logger.IsTraceEnabled)
{
logger.Trace("Successfully validated transport");
}
return(PingResult.SUCCESS);
}
else
{
if (logger.IsTraceEnabled)
{
logger.Trace("Unknown response status: %s", respStatus);
}
return(PingResult.FAIL);
}
}
catch (Exception e)
{
if (e.Message.Contains("CacheNotFoundException"))
{
return(PingResult.CACHE_DOES_NOT_EXIST);
}
else
{
return(PingResult.FAIL);
}
}
}
/// <summary>
/// USed to get the versioned operation response. It contains version information of the data in the server.
/// </summary>
/// <param name="transport"></param>
/// <param name="param"></param>
/// <returns>Version data on the entry picked</returns>
protected VersionedOperationResponse returnVersionedOperationResponse(Transport transport, HeaderParams param)
{
byte respStatus = readHeaderAndValidate(transport, param);
if (logger.IsTraceEnabled)
{
logger.Trace("Read response status : " + respStatus);
}
VersionedOperationResponse.RspCode code;
if (respStatus == NO_ERROR_STATUS)
{
code = VersionedOperationResponse.RspCode.SUCCESS;
}
else if (respStatus == NOT_PUT_REMOVED_REPLACED_STATUS)
{
code = VersionedOperationResponse.RspCode.MODIFIED_KEY;
}
else if (respStatus == KEY_DOES_NOT_EXIST_STATUS)
{
code = VersionedOperationResponse.RspCode.NO_SUCH_KEY;
}
else
{
IllegalStateException e = new IllegalStateException("Unknown response status: " + respStatus);
logger.Warn(e);
throw e;
}
byte[] prevValue = returnPossiblePrevValue(transport);
return(new VersionedOperationResponse(prevValue, code));
}
/// <summary>
/// Create a new <see cref="JsonPostRestRequest"/>.
/// </summary>
/// <param name="urlParameters">The URL parameters.</param>
/// <param name="headers">The header parameters.</param>
/// <param name="body">The body parameters.</param>
protected JsonPostRestRequest(UrlParams urlParameters, HeaderParams headers, BodyParams body)
: base(HttpMethod.Post, urlParameters, headers, body)
{
}
/// <summary>
/// Create a new GetRequest.
/// </summary>
/// <param name="urlParams">Template replacements for an API's URL.</param>
/// <param name="headers">HTTP headers to add to the request.</param>
/// <param name="query">Parameters for the query string.</param>
protected GetRestRequest(UrlParams urlParams, HeaderParams headers, QueryParams query) :
base(HttpMethod.Get, urlParams, headers, query, BodyParams.Empty, DataParams.Empty)
{
}
/// <summary>
/// Create a new multipart POST request.
/// </summary>
/// <param name="urlParams">The parameters in the URL.</param>
/// <param name="headerParams">The parameters in the HTTP headerParams.</param>
/// <param name="bodyParams">The parameters in the HTTP body.</param>
/// <param name="dataParams">The data parameters.</param>
protected MultipartPostRestRequest(UrlParams urlParams, HeaderParams headerParams, BodyParams bodyParams, DataParams dataParams)
: base(HttpMethod.Post, urlParams, headerParams, bodyParams, dataParams) { }
public void AddHeaderParameter(string name, string value) => HeaderParams.Add(new KeyValuePair <string, string>(name, value));
/// <summary>
/// Create a new REST request whose body is a JSON object containing the parameters.
/// </summary>
/// <param name="method">The method to use.</param>
/// <param name="urlParameters">The URL parameters.</param>
/// <param name="headers">The header parameters.</param>
/// <param name="body">The body parameters.</param>
protected JsonRestRequest(HttpMethod method, UrlParams urlParameters, HeaderParams headers, BodyParams body)
: base(method, urlParameters, headers, QueryParams.Empty, body, DataParams.Empty)
{
}
/**
* Magic | Message Id | Op code | Status | Topology Change Marker
*/
protected byte readHeaderAndValidate(Transport transport, HeaderParams param)
{
return(codec.readHeader(transport, param));
}
/// <summary>
/// Create a new MultipartRequest.
/// </summary>
/// <param name="method">The HTTP method for this request.</param>
/// <param name="urlParams">Template replacements for an API's URL.</param>
/// <param name="headers">HTTP headers to add to the request.</param>
/// <param name="post">Parameters for the body.</param>
/// <param name="data">File references to be sent as part of the request.</param>
protected MultipartRestRequest(HttpMethod method, UrlParams urlParams, HeaderParams headers, BodyParams post, DataParams data) :
base(method, urlParams, headers, QueryParams.Empty, post, data)
{
}
/// <summary>
/// Create a new <see cref="B2AuthenticationToken"/>.
/// </summary>
/// <param name="authString">The string representing the authorization token returned from a B2 authorize account request.</param>
/// <param name="endpoint">The B2 endpoint for authorized API calls.</param>
public B2AuthenticationToken(string authString, Uri endpoint)
{
Headers = new HeaderParams(RequiredParam.Of("Authorization", authString));
Endpoint = endpoint;
}
