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