private static void HandleRpcError(RpcResponseMessage response) { if (response.HasError) { throw new RpcResponseException(new RpcError(response.Error, response.Description)); } }
private async Task HandleIncomingMessagesAsync(ClientWebSocket client, CancellationToken cancellationToken) { var lastChunk = string.Empty; var readBufferSize = 512; int bytesRead = 0; byte[] chunkedBuffer = new byte[readBufferSize]; bytesRead = await ReceiveBufferedResponseAsync(client, chunkedBuffer, cancellationToken).ConfigureAwait(false); while (!cancellationToken.IsCancellationRequested && bytesRead > 0) { var data = Encoding.UTF8.GetString(chunkedBuffer, 0, bytesRead); var dechunkedData = DeChunkResponse(data); foreach (var chunk in dechunkedData) { var localChunk = chunk; if (!string.IsNullOrEmpty(lastChunk)) { localChunk = lastChunk + localChunk; } try { var temp = JsonConvert.DeserializeAnonymousType(localChunk, new { id = string.Empty }, JsonSerializerSettings); if (temp.id == null) { // assume streaming subscription response RpcStreamingResponseMessage streamingResult = JsonConvert.DeserializeObject <RpcStreamingResponseMessage>(localChunk, JsonSerializerSettings); var streamingArgs = new RpcStreamingResponseMessageEventArgs(streamingResult); OnStreamingMessageRecieved(this, streamingArgs); } else { // assume regular rpc response RpcResponseMessage result = JsonConvert.DeserializeObject <RpcResponseMessage>(localChunk, JsonSerializerSettings); var rpcEventArgs = new RpcResponseMessageEventArgs(result); OnMessageRecieved(this, rpcEventArgs); continue; } lastChunk = string.Empty; } catch (Exception) { lastChunk = localChunk; // swallow... continue; } } bytesRead = await ReceiveBufferedResponseAsync(client, chunkedBuffer, cancellationToken).ConfigureAwait(false); } }
private void HandleRpcError(RpcResponseMessage response) { if (response.HasError) { throw new RpcResponseException(new RpcError(response.Error.Code, response.Error.Message, response.Error.Data)); } }
protected void HandleRpcError(RpcResponseMessage response) { if (response.HasError) { throw new RpcResponseException(new Nethereum.JsonRpc.Client.RpcError(response.Error.Code, response.Error.Message, response.Error.Data)); } }
protected void HandleRpcError(RpcResponseMessage response, string reqMsg) { if (response.HasError) { throw new RpcResponseException(new RpcError(response.Error.Code, response.Error.Message + ": " + reqMsg, response.Error.Data)); } }
protected void HandleRpcError(RpcResponseMessage response) { if (response.HasError) { throw new Exception(); } //throw new RpcResponseException(new RpcError(response.Error.Code, response.Error.Message, // response.Error.Data)); }
public static T AnalysisResponse <T>(RpcResponseMessage rpcResponseMessage) where T : class, new() { T result = new T(); if (!rpcResponseMessage.HasError) { result = rpcResponseMessage.Result.ToObject <T>(); } return(result); }
public static string IdAsString(this RpcResponseMessage message) { if (message.Id == null) { return(null); } var id = message.Id.ToString(); return(id); }
private T ConvertResponse <T>(RpcResponseMessage response, string route = null) { HandleRpcError(response); try { return(response.GetResult <T>()); } catch (FormatException formatException) { throw new RpcResponseFormatException("Invalid format found in RPC response", formatException); } }
public static int?IdAsInteger(this RpcResponseMessage message) { if (message.Id == null) { return(null); } if (int.TryParse(message.Id.ToString(), out var id)) { return(id); } return(null); }
/// <summary> /// Try convert ID from message to GUID. /// if id null or cannot cast to guid then return Guid.Empty /// </summary> /// <returns>Id as GUID or Guid.Empty</returns> public static Guid IdAsGuid(this RpcResponseMessage message) { if (message.Id == null) { return(Guid.Empty); } if (Guid.TryParse(message.Id.ToString(), out var id)) { return(id); } return(Guid.Empty); }
public static RpcResponseMessage BuildResponse(HttpWebResponse response) { RpcResponseMessage rpcResponseMessage = null; if (response != null) { using (var streamReader = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) using (var reader = new JsonTextReader(streamReader)) { string temp = streamReader.ReadToEnd(); rpcResponseMessage = temp.ToObject <RpcResponseMessage>(); } } return(rpcResponseMessage); }
protected override async Task <RpcResponseMessage> SendAsync(RpcRequestMessage request, string route = null) { RpcLogger rpcLogger = new RpcLogger(_log); RpcResponseMessage rpcResponseMessage; try { var cancellationTokenSource = new CancellationTokenSource(); cancellationTokenSource.CancelAfter(ConnectionTimeout); using (var pipeStream = new NamedPipeClientStream(IpcPath)) { await pipeStream.ConnectAsync(cancellationTokenSource.Token); string str = JsonConvert.SerializeObject(request, JsonSerializerSettings); byte[] bytes = Encoding.UTF8.GetBytes(str); rpcLogger.LogRequest(str); await pipeStream.WriteAsync(bytes, 0, bytes.Length, cancellationTokenSource.Token); using (MemoryStream fullResponse = await ReceiveFullResponseAsync(pipeStream, cancellationTokenSource.Token)) { fullResponse.Position = 0L; using (StreamReader streamReader = new StreamReader(fullResponse)) { using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader)) { RpcResponseMessage responseMessage = JsonSerializer.Create(JsonSerializerSettings).Deserialize <RpcResponseMessage>(jsonTextReader); rpcLogger.LogResponse(responseMessage); rpcResponseMessage = responseMessage; } } } } } catch (TaskCanceledException ex) { var exception = new RpcClientTimeoutException($"Rpc timeout after {ConnectionTimeout.TotalMilliseconds} milliseconds", ex); rpcLogger.LogException(exception); throw exception; } catch (Exception ex) { var unknownException = new RpcClientUnknownException("Error occurred when trying to send ipc requests(s)", ex); rpcLogger.LogException(unknownException); throw unknownException; } return(rpcResponseMessage); }
public static T AnalysisResponse <T>(RpcResponseMessage rpcResponseMessage) where T : class, new() { T result = new T(); if (!rpcResponseMessage.HasError) { result = rpcResponseMessage.Result.ToObject <T>(); } else { throw new Exception(rpcResponseMessage.Error.ToJson()); } return(result); }
public void LogResponse(RpcResponseMessage responseMessage) { ResponseMessage = responseMessage; if (IsLogTraceEnabled()) { Log.LogTrace(GetRpcResponseLogMessage()); } if (HasError(responseMessage) && IsLogErrorEnabled()) { if (!IsLogTraceEnabled()) { Log.LogError(GetRpcResponseLogMessage()); } Log.LogError($"RPC Response Error: {responseMessage.Description}"); } }
private bool HasError(RpcResponseMessage message) { return(message.Error > 0 && message.HasError); }
public RpcResponseMessageEventArgs(RpcResponseMessage message) { this.Message = message; }
public static string DataAsString(this RpcResponseMessage message) { return(message.Result?.ToString()); }