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; }