public static JsonRpcResponse CreateSuccessfulJsonRpcResponse(JsonRpcRequest request, JToken result) { return new JsonRpcResponse(request) { Result = result }; }
private JsonRpcResponse OnReceivedSmall(JsonRpcRequest jsonRpcRequest) { var testModel = jsonRpcRequest.Params.ToObject<SmallObjectTestModel>(); testModel.ServerReceivedTime = DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture); return JsonRpcResponse.Factory.CreateSuccessfulJsonRpcResponse(jsonRpcRequest, JToken.FromObject(testModel)); }
private JsonRpcResponse ExecuteCommand(JsonRpcRequest request) { try { var json = request.@params == null ? null : [email protected](); var result = _processor.Process(request.method, json); return new JsonRpcResponse { jsonrpc = request.jsonrpc, result = result, error = null, id = request.id, }; } catch (Exception ex) { return new JsonRpcResponse { jsonrpc = request.jsonrpc, result = null, error = new JsonRpcError { code = 1, message = ex.GetBaseException().Message, data = ex, }, id = request.id, }; } }
private JsonRpcResponse(JsonRpcRequest request) { Debug.Assert(request.IsNotification == false, "Cannot respond to a notification."); JsonRpc = JsonRpcConstants.Version; Error = null; Result = null; Id = request.Id; }
protected JsonRpcResponse(JsonRpcRequest jsonRpcRequest) { if (jsonRpcRequest.IsNotification) { throw new NotSupportedException("Cannot respond to a notification."); } JsonRpc = JsonRpcConstants.Version; Id = jsonRpcRequest.Id; }
public void ToggleMute() { var request = new JsonRpcRequest() { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.ToggleMute" }; client.Execute<JToken>(request, (response, exception) => {}); }
public static JsonRpcResponse CreateErrorJsonRpcResponse(JsonRpcRequest request, String errorMessage) { return new JsonRpcResponse(request) { Error = new JsonRpcError() { Code = 0, Message = errorMessage } }; }
public void SetVolume(int volume) { var request = new JsonRpcRequest() { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.SetVolume", Parameters = new JArray { volume } }; client.Execute<JToken>(request, (response, exception) => {}); }
public void Log(string message) { var request = new JsonRpcRequest { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.Log", Parameters = new JArray { message } }; client.Execute<JToken>(request, (response, exception) => {}); }
public void Log(string message, LogLevel level) { // All the log levels are lowercase characters. var request = new JsonRpcRequest() { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.Log", Parameters = new JArray { message, level.ToString().ToLower() } }; client.Execute<JToken>(request, (response, exception) => {}); }
public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest jsonRpcRequest) { Debug.Assert(jsonRpcRequest != null && jsonRpcRequest.Id != null && jsonRpcRequest.Id != String.Empty); JTokenStreamContent streamContent = new JTokenStreamContent(JToken.FromObject(jsonRpcRequest)); TaskCompletionSource<JsonRpcResponse> sendJsonRpcRequestTask = new TaskCompletionSource<JsonRpcResponse>(jsonRpcRequest); _outgoingJsonRpcRequests.Enqueue(streamContent); _incompleteJsonRpcRequests.AddOrUpdate(jsonRpcRequest.Id, sendJsonRpcRequestTask, (k, v) => { Debug.Assert(false, "Should not send requests with the same id."); return sendJsonRpcRequestTask; }); return await sendJsonRpcRequestTask.Task; }
private JsonRpcRequest CreateRequest(object[] parameters) { JsonRpcRequest jsonRequest = new JsonRpcRequest(); jsonRequest.Id = Guid.NewGuid().ToString(); // TODO: mb int? jsonRequest.Method = _operation.Name; var args = new JObject(); int paramIndex = 0; foreach (var parameter in _requestMessage.Body.Parts) { var token = JToken.FromObject(parameters[paramIndex]); args.Add(new JProperty(parameter.Name, token)); paramIndex++; } jsonRequest.Params = args; return jsonRequest; }
private void OnReceivedRequestHandler(object sender, JsonRpcRequest jsonRpcRequest) { JsonRpcResponse jsonRpcResponse; switch (jsonRpcRequest.Method) { case "Large": jsonRpcResponse = OnReceivedLarge(jsonRpcRequest); break; case "Small": jsonRpcResponse = OnReceivedSmall(jsonRpcRequest); break; default: throw new NotSupportedException(); } if (!jsonRpcRequest.IsNotification) { _jsonRpcStreamClient.SendResponseToClient(jsonRpcResponse); } }
protected JsonRpcResponse(JsonRpcRequest request, JsonRpcError error) : this(request) { Error = error; }
public void SendResponse(JsonRpcRequest request) { client.SendResponse(request, new Dictionary <string, object>()); }
private async Task <JsonRpcResponse> ExecuteAsync(JsonRpcRequest request, string methodName, (MethodInfo Info, bool ReadOnly) method, JsonRpcContext context)
/// <summary> /// Create and execute custom json-rpc method /// </summary> /// <typeparam name="T">Custom type. JsonConvert will try to convert json-response to you custom object</typeparam> /// <param name="api">api name</param> /// <param name="method">Sets json-rpc "method" field</param> /// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param> /// <param name="data">Sets to json-rpc params field. JsonConvert use`s for convert array of data to string.</param> /// <returns></returns> /// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception> public Task <JsonRpcResponse <T> > CustomGetRequestAsync <T>(string api, string method, object[] data, CancellationToken token) { var jsonRpc = new JsonRpcRequest(JsonSerializerSettings, api, method, data); return(ConnectionManager.RepeatExecuteAsync <T>(jsonRpc, JsonSerializerSettings, token)); }
private async ValueTask sendMessage(CancellationToken cancelToken, ClientWebSocket cws, JsonRpcRequest request) { var _json_string = JsonConvert.SerializeObject(request); #if DEBUG DRLogger.SNG.WriteC(this, _json_string); #endif var _message = Encoding.UTF8.GetBytes(_json_string); await cws.SendAsync( new ArraySegment <byte>(_message), WebSocketMessageType.Text, endOfMessage : true, cancellationToken : cancelToken ); }
/// <summary> /// Create and execute custom json-rpc method /// </summary> /// <param name="method">Sets json-rpc "method" field</param> /// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param> /// <param name="data">Sets to json-rpc params field. JsonConvert use`s for convert array of data to string.</param> /// <returns></returns> /// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception> public JsonRpcResponse CustomGetRequest(string method, CancellationToken token, params object[] data) { var jsonRpc = new JsonRpcRequest(_jsonSerializerSettings, method, data); return(_connectionManager.Execute(jsonRpc, token)); }
private static JsonRpcResponse CreateErrorResponse(JsonRpcRequest request, JsonRpcError error) { return new JsonRpcResponse(request, error); }
public void GetVolumn(Action<int, Exception> callback) { var request = new JsonRpcRequest() { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.GetVolume" }; client.Execute<int>(request, (rpcResponse, exception) => { if (exception != null) { callback(0, exception); } else { callback(rpcResponse.Result, null); } }); return ; }
public T MakeRequest <T>(Methods method, params object[] parameters) { var jsonRpcRequest = new JsonRpcRequest(1, method.ToString(), parameters); var webRequest = (HttpWebRequest)WebRequest.Create(_url); SetBasicAuthHeader(webRequest, _user, _pwd); webRequest.Credentials = new NetworkCredential(_user, _pwd); webRequest.ContentType = "application/json-rpc"; webRequest.Method = "POST"; webRequest.Proxy = null; webRequest.Timeout = 3000; var byteArray = jsonRpcRequest.GetBytes(); webRequest.ContentLength = jsonRpcRequest.GetBytes().Length; using (var dataStream = webRequest.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); dataStream.Dispose(); } try { string json; using (var webResponse = webRequest.GetResponse()) { using (var stream = webResponse.GetResponseStream()) { using (var reader = new StreamReader(stream)) { var result = reader.ReadToEnd(); reader.Dispose(); json = result; } } } var rpcResponse = JsonConvert.DeserializeObject <JsonRpcResponse <T> >(json); return(rpcResponse.Result); } catch (WebException webException) { var webResponse = webException.Response as HttpWebResponse; if (webResponse != null) { switch (webResponse.StatusCode) { case HttpStatusCode.InternalServerError: { using (var stream = webResponse.GetResponseStream()) { if (stream == null) { throw new Exception("The RPC request was either not understood by the server or there was a problem executing the request", webException); } using (var reader = new StreamReader(stream)) { var result = reader.ReadToEnd(); reader.Dispose(); try { var jsonRpcResponseObject = JsonConvert.DeserializeObject <JsonRpcResponse <object> >(result); //var internalServerErrorException = new Exception(jsonRpcResponseObject.Error.Message, webException) //{ // RpcErrorCode = jsonRpcResponseObject.Error.Code //}; //throw internalServerErrorException; throw new Exception(result, webException); } catch (JsonException) { throw new Exception(result, webException); } } } } default: throw new Exception("Unhandled web exception", webException); } } if (webException.Message == "The operation has timed out") { throw new Exception(webException.Message); } throw new Exception("An unknown web exception occured while trying to read the response", webException); } catch (Exception ex) { throw new Exception($"A problem was encountered while calling MakeRpcRequest() for: {jsonRpcRequest.Method}", ex); } }
public JsonRpcResponse <T> MakeRequest <T>(string rpcMethod, object parameters, string id = "KodiJSON-RPC", int timeout = 50000) { var jsonRpcRequest = new JsonRpcRequest { Id = id, Method = rpcMethod, Parameters = parameters }; if (Convert.ToBoolean(ConfigurationManager.AppSettings["Debug"])) { Console.WriteLine(jsonRpcRequest.ToString()); } var uri = $"{_service.Host}:{_service.Port}/jsonrpc"; var webRequest = (HttpWebRequest)WebRequest.Create(uri); webRequest.ContentType = "application/json-rpc"; webRequest.KeepAlive = false; webRequest.Method = "POST"; webRequest.Timeout = timeout; webRequest.Credentials = new NetworkCredential(_service.Username, _service.Password); try { using (var requestStream = webRequest.GetRequestStream()) { using (var requestWriter = new StreamWriter(requestStream)) { requestWriter.Write(jsonRpcRequest.ToString()); } } } catch (Exception e) { throw new RpcException("There was a problem sending the request to Kodi.", e); } try { string json; using (var webResponse = webRequest.GetResponse()) { using (var responseStream = webResponse.GetResponseStream()) { if (responseStream == null) { throw new RpcException("Response stream is empty."); } using (var responseReader = new StreamReader(responseStream, Encoding.UTF8)) { json = responseReader.ReadToEnd(); } } } var rpcResponse = JsonConvert.DeserializeObject <JsonRpcResponse <T> >(json); if (rpcResponse.Error == null) { return(rpcResponse); } var internalServerErrorException = new RpcInternalServerErrorException(rpcResponse.Error) { RpcErrorCode = rpcResponse.Error.Code }; throw internalServerErrorException; } catch (WebException e) { var webResponse = e.Response as HttpWebResponse; if (webResponse != null) { switch (webResponse.StatusCode) { case HttpStatusCode.InternalServerError: { using (var stream = webResponse.GetResponseStream()) { if (stream == null) { throw new RpcException("The RPC request was either not understood by the server or there was a problem executing the request", e); } using (var reader = new StreamReader(stream)) { var result = reader.ReadToEnd(); reader.Dispose(); try { var jsonRpcResponseObject = JsonConvert.DeserializeObject <JsonRpcResponse <object> >(result); var internalServerErrorException = new RpcInternalServerErrorException(jsonRpcResponseObject.Error.Message, e) { RpcErrorCode = jsonRpcResponseObject.Error.Code }; throw internalServerErrorException; } catch (JsonException) { throw new RpcException(result, e); } } } } default: throw new RpcException("The RPC request was either not understood by the server or there was a problem executing the request", e); } } if (e.Message == "The operation has timed out") { throw new RpcRequestTimeoutException(e.Message); } throw new RpcException("An unknown web exception occured while trying to read the JSON response", e); } catch (JsonException e) { throw new RpcResponseDeserializationException( "There was a problem deserializing the response from Kodi.", e); } catch (ProtocolViolationException e) { throw new RpcException("Unable to connect to the server.", e); } catch (Exception e) { throw new Exception($"A problem was encountered while calling MakeRpcRequest() for: {jsonRpcRequest.Method} with request object {jsonRpcRequest}: \nException: {e.Message}"); // with parameters: {qryParams}. \nException: {e.Message}"); } }
private dynamic odooServerCall <T>(string url, JsonRpcRequestParameter parameter) { var tmpData = new JsonRpcRequest(parameter); string requestContent = ""; // this.Password = Settings.UserPassword; if (Device.RuntimePlatform == "Android") { requestContent = JsonConvert.SerializeObject(tmpData); } else { //Dictionary<string, dynamic> paramsDic = new Dictionary<string, dynamic>(); //paramsDic.Add("service", parameter.Service); //paramsDic.Add("method", parameter.Method); //paramsDic.Add("args", parameter.Argument); //Dictionary<string, dynamic> jObj = new Dictionary<string, dynamic>(); //jObj.Add("jsonrpc", "2.0"); //jObj.Add("method", "call"); //jObj.Add("params", paramsDic); //var formatData = JsonConvert.SerializeObject(jObj); //requestContent = formatData; } System.Diagnostics.Debug.WriteLine("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW " + requestContent); HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(new Uri(url)); request.ContentType = "application/json"; request.Method = "POST"; try { App.responseState = true; App.NetAvailable = true; IAsyncResult resultRequest = request.BeginGetRequestStream(null, null); Stream streamInput = request.EndGetRequestStream(resultRequest); byte[] byteArray = Encoding.UTF8.GetBytes(requestContent); streamInput.WriteAsync(byteArray, 0, byteArray.Length); streamInput.FlushAsync(); // Receive data from server IAsyncResult resultResponse = request.BeginGetResponse(null, null); HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(resultResponse); Stream streamResponse = response.GetResponseStream(); StreamReader streamRead = new StreamReader(streamResponse); var resultData = streamRead.ReadToEndAsync(); var responseData = resultData.Result; streamResponse.FlushAsync(); if (Device.RuntimePlatform == "iOS") { string rspData = string.Join("", responseData); try { JObject jsonObj = JObject.Parse(rspData); Dictionary <string, dynamic> dictObj = jsonObj.ToObject <Dictionary <string, dynamic> >(); return(dictObj["result"]); } catch (Exception ea) { return(responseData); } } else { try { JsonRpcResponse <T> jsonRpcResponse = JsonConvert.DeserializeObject <JsonRpcResponse <T> >(responseData); if (jsonRpcResponse.Error != null) { return("Odoo Error"); } else { return(jsonRpcResponse.Result); } } catch (Exception ea) { return(responseData); } } } catch (Exception ea) { if (ea.Message.Contains("(Network is unreachable)") || ea.Message.Contains("NameResolutionFailure")) { App.NetAvailable = false; } else if (ea.Message.Contains("(503) Service Unavailable")) { App.responseState = false; } System.Diagnostics.Debug.WriteLine(ea.Message); // throw; } return(default(T)); }
public void PlayEpisode(int id) { JObject args = new JObject(); args.Add(new JProperty("episodeid", id)); var request = new JsonRpcRequest { Credentials = this.credentials, Id = GetRequestId(), Method = "XBMC.Play", Parameters = args }; client.Execute<JToken>(request, (response, exception) => { }); }
protected JsonRpcResponse(JsonRpcRequest request, Object result) : this(request) { Result = JToken.FromObject(result); }
private StringContent GetPayload(JsonRpcRequest request) => new StringContent(new EthereumJsonSerializer().Serialize(request), Encoding.UTF8, "application/json");
public void SendResponse(JsonRpcRequest request, object response) { client.SendResponse(request, response); }
public void SendNotificationAsync(JsonRpcRequest jsonRpcRequest) { Debug.Assert(jsonRpcRequest != null && jsonRpcRequest.Id != null && jsonRpcRequest.Id != String.Empty); Debug.Assert(jsonRpcRequest.IsNotification == true); JTokenStreamContent streamContent = new JTokenStreamContent(JToken.FromObject(jsonRpcRequest)); _outgoingJsonRpcRequests.Enqueue(streamContent); }
private static JsonRpcResponse CreateGoodResponse(JsonRpcRequest request, Object result) { return new JsonRpcResponse(request, result); }
public void SendRequestToClient(JsonRpcRequest request) { AddJObjectToQueueAsync(JObject.FromObject(request)); }
public T MakeRequest <T>(RpcMethods rpcMethod, params object[] parameters) { id++; var jsonRpcRequest = new JsonRpcRequest(id, rpcMethod.ToString(), parameters); var webRequest = (HttpWebRequest)WebRequest.Create(_coinService.Parameters.SelectedDaemonUrl); byte[] byteArray; if (rpcMethod == RpcMethods.stop) /* Dirty workaround to properly support json notification syntax, lets merge this into library later properly*/ { var jsonRpcRequestNotification = new JsonRpcRequestNotification(rpcMethod.ToString(), parameters); SetBasicAuthHeader(webRequest, _coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.Credentials = new NetworkCredential(_coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.ContentType = "application/json-rpc"; webRequest.Method = "POST"; webRequest.Proxy = null; webRequest.Timeout = _coinService.Parameters.RpcRequestTimeoutInSeconds * GlobalConstants.MillisecondsInASecond; byteArray = jsonRpcRequestNotification.GetBytes(); webRequest.ContentLength = jsonRpcRequestNotification.GetBytes().Length; } else if (rpcMethod == RpcMethods.waitforchange) /* Latest XAYA library addition pases waitforchange arguments as array, this also needs special handling*/ { string[] aRR = new string[parameters.Length]; for (int s = 0; s < parameters.Length; s++) { aRR[s] = parameters[s].ToString(); } var jsonRpcRequestNotification = new JsonRpcRequestArray(id, rpcMethod.ToString(), aRR); SetBasicAuthHeader(webRequest, _coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.Credentials = new NetworkCredential(_coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.ContentType = "application/json-rpc"; webRequest.Method = "POST"; webRequest.Proxy = null; webRequest.Timeout = _coinService.Parameters.RpcRequestTimeoutInSeconds * GlobalConstants.MillisecondsInASecond; byteArray = jsonRpcRequestNotification.GetBytes(); webRequest.ContentLength = jsonRpcRequestNotification.GetBytes().Length; } else { SetBasicAuthHeader(webRequest, _coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.Credentials = new NetworkCredential(_coinService.Parameters.RpcUsername, _coinService.Parameters.RpcPassword); webRequest.ContentType = "application/json-rpc"; webRequest.Method = "POST"; webRequest.Proxy = null; webRequest.Timeout = _coinService.Parameters.RpcRequestTimeoutInSeconds * GlobalConstants.MillisecondsInASecond; byteArray = jsonRpcRequest.GetBytes(); webRequest.ContentLength = jsonRpcRequest.GetBytes().Length; } if (rpcMethod == RpcMethods.waitforchange) /* Dirty workaround to properly support json notification syntax, lets merge this into library later properly*/ { webRequest.Timeout = int.MaxValue; } try { using (var dataStream = webRequest.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); dataStream.Dispose(); } } catch (Exception exception) { Console.WriteLine("There was a problem sending the request to the wallet", exception); return(default(T)); } try { string json; using (var webResponse = webRequest.GetResponse()) { using (var stream = webResponse.GetResponseStream()) { using (var reader = new StreamReader(stream)) { var result = reader.ReadToEnd(); reader.Dispose(); json = result; } } } if (json != "") { var rpcResponse = JsonConvert.DeserializeObject <JsonRpcResponse <T> >(json); return(rpcResponse.Result); } else { return(default(T)); } } catch (WebException webException) { #region RPC Internal Server Error (with an Error Code) var webResponse = webException.Response as HttpWebResponse; if (webResponse != null) { switch (webResponse.StatusCode) { case HttpStatusCode.InternalServerError: { using (var stream = webResponse.GetResponseStream()) { if (stream == null) { throw new RpcException("The RPC request was either not understood by the server or there was a problem executing the request", webException); } using (var reader = new StreamReader(stream)) { var result = reader.ReadToEnd(); reader.Dispose(); try { var jsonRpcResponseObject = JsonConvert.DeserializeObject <JsonRpcResponse <object> >(result); var internalServerErrorException = new RpcInternalServerErrorException(jsonRpcResponseObject.Error.Message, webException) { RpcErrorCode = jsonRpcResponseObject.Error.Code }; throw internalServerErrorException; } catch (JsonException) { throw new RpcException(result, webException); } } } } default: throw new RpcException("The RPC request was either not understood by the server or there was a problem executing the request", webException); } } #endregion #region RPC Time-Out if (webException.Message == "The operation has timed out") { throw new RpcRequestTimeoutException(webException.Message); } #endregion return(default(T)); } catch (JsonException jsonException) { throw new RpcResponseDeserializationException("There was a problem deserializing the response from the wallet", jsonException); } catch (ProtocolViolationException protocolViolationException) { throw new RpcException("Unable to connect to the server", protocolViolationException); } catch (Exception exception) { var queryParameters = jsonRpcRequest.Parameters.Cast <string>().Aggregate(string.Empty, (current, parameter) => current + (parameter + " ")); throw new Exception($"A problem was encountered while calling MakeRpcRequest() for: {jsonRpcRequest.Method} with parameters: {queryParameters}. \nException: {exception.Message}"); } }
/// <summary> /// /// </summary> /// <param name="message"></param> public static void SendCommandQ(JsonRpcRequest message) { CommandQ.Enqueue(message); }