public async Task SendJsonRpcResult(JsonRpcResult result)
{
string SerializeTimeoutException()
{
JsonRpcErrorResponse error = _jsonRpcService.GetErrorResponse(ErrorCodes.Timeout, "Request was canceled due to enabled timeout.");
return(_jsonSerializer.Serialize(error));
}
string resultData;
try
{
resultData = result.IsCollection ? _jsonSerializer.Serialize(result.Responses) : _jsonSerializer.Serialize(result.Response);
}
catch (Exception e) when(e.InnerException is OperationCanceledException)
{
resultData = SerializeTimeoutException();
}
catch (OperationCanceledException)
{
resultData = SerializeTimeoutException();
}
await SendRawAsync(resultData);
}
public void IncorrectMethodNameTest()
{
JsonRpcErrorResponse response = TestRequest <IEthModule>(Substitute.For <IEthModule>(), "incorrect_method") as JsonRpcErrorResponse;
Assert.AreEqual(response.Error.Code, JsonRpcService.ErrorCodes[ErrorType.MethodNotFound]);
Assert.AreEqual(null, response.Result);
Assert.AreEqual(response.JsonRpc, "2.0");
}
public void Get_block_rlp_when_missing()
{
debugBridge.GetBlockRlp(1).Returns((byte[])null);
DebugRpcModule rpcModule = new DebugRpcModule(LimboLogs.Instance, debugBridge, jsonRpcConfig);
JsonRpcErrorResponse response = RpcTest.TestRequest <IDebugRpcModule>(rpcModule, "debug_getBlockRlp", "1") as JsonRpcErrorResponse;
Assert.AreEqual(-32001, response?.Error.Code);
}
private string Invoke(string json)
{
JsonRpcRequest request = null;
try
{
request = JsonConvert.DeserializeObject <JsonRpcRequest>(json);
var method = _registry.GetMethod(request.method);
var result = method.Execute(request.@params);
//notification so don't return the result
if (request.id == default)
{
return(null);
}
var response = new JsonRpcResponse
{
id = request.id,
result = result
};
var jsonResult = JsonConvert.SerializeObject(response);
return(jsonResult);
}
catch (RpcException e)
{
var errorResult = new JsonRpcErrorResponse
{
id = request.id,
error = new RpcError
{
code = e.Code,
message = e.Message
}
};
var errorJson = JsonConvert.SerializeObject(errorResult);
return(errorJson);
}
catch (Exception e)
{
if (request == null || request.id == default)
{
return(null);
}
var errorResult = new JsonRpcErrorResponse
{
id = request.id,
error = new RpcError
{
message = e.Message,
code = -32000
}
};
var errorJson = JsonConvert.SerializeObject(errorResult);
return(errorJson);
}
}
public void Get_block_rlp_when_missing()
{
IDebugBridge debugBridge = Substitute.For <IDebugBridge>();
debugBridge.GetBlockRlp(1).Returns((byte[])null);
DebugModule module = new DebugModule(NullLogManager.Instance, debugBridge);
JsonRpcErrorResponse response = RpcTest.TestRequest <IDebugModule>(module, "debug_getBlockRlp", "1") as JsonRpcErrorResponse;
Assert.AreEqual(-32601, response.Error.Code);
}
public void Get_block_rlp_by_hash_when_missing()
{
BlockDecoder decoder = new BlockDecoder();
Rlp rlp = decoder.Encode(Build.A.Block.WithNumber(1).TestObject);
debugBridge.GetBlockRlp(Keccak.Zero).Returns((byte[])null);
DebugRpcModule rpcModule = new DebugRpcModule(LimboLogs.Instance, debugBridge, jsonRpcConfig);
JsonRpcErrorResponse response = RpcTest.TestRequest <IDebugRpcModule>(rpcModule, "debug_getBlockRlpByHash", $"{Keccak.Zero.Bytes.ToHexString()}") as JsonRpcErrorResponse;
Assert.AreEqual(-32001, response.Error.Code);
}
public void Get_block_rlp_by_hash_when_missing()
{
BlockDecoder decoder = new BlockDecoder();
IDebugBridge debugBridge = Substitute.For <IDebugBridge>();
Rlp rlp = decoder.Encode(Build.A.Block.WithNumber(1).TestObject);
debugBridge.GetBlockRlp(Keccak.Zero).Returns((byte[])null);
DebugModule module = new DebugModule(NullLogManager.Instance, debugBridge);
JsonRpcErrorResponse response = RpcTest.TestRequest <IDebugModule>(module, "debug_getBlockRlpByHash", $"{Keccak.Zero.Bytes.ToHexString()}") as JsonRpcErrorResponse;
Assert.AreEqual(-32601, response.Error.Code);
}
public async Task ReceiveAsync(Memory <byte> data)
{
string SerializeTimeoutException()
{
JsonRpcErrorResponse error = _jsonRpcService.GetErrorResponse(ErrorCodes.Timeout, "Request was canceled due to enabled timeout.");
return(_jsonSerializer.Serialize(error));
}
Stopwatch stopwatch = Stopwatch.StartNew();
using JsonRpcResult result = await _jsonRpcProcessor.ProcessAsync(Encoding.UTF8.GetString(data.ToArray()));
string resultData;
try
{
resultData = result.IsCollection ? _jsonSerializer.Serialize(result.Responses) : _jsonSerializer.Serialize(result.Response);
}
catch (Exception e) when(e.InnerException is OperationCanceledException)
{
resultData = SerializeTimeoutException();
}
catch (OperationCanceledException)
{
resultData = SerializeTimeoutException();
}
await SendRawAsync(resultData);
if (result.IsCollection)
{
_jsonRpcLocalStats.ReportCalls(result.Reports);
_jsonRpcLocalStats.ReportCall(new RpcReport("# collection serialization #", stopwatch.ElapsedMicroseconds(), true));
}
else
{
_jsonRpcLocalStats.ReportCall(result.Report, stopwatch.ElapsedMicroseconds());
}
}
public virtual async Task <int> SendJsonRpcResult(JsonRpcResult result)
{
void SerializeTimeoutException(MemoryStream stream)
{
JsonRpcErrorResponse error = _jsonRpcService.GetErrorResponse(ErrorCodes.Timeout, "Request was canceled due to enabled timeout.");
_jsonSerializer.Serialize(stream, error);
}
await using MemoryStream resultData = new();
try
{
if (result.IsCollection)
{
_jsonSerializer.Serialize(resultData, result.Responses);
}
else
{
_jsonSerializer.Serialize(resultData, result.Response);
}
}
catch (Exception e) when(e.InnerException is OperationCanceledException)
{
SerializeTimeoutException(resultData);
}
catch (OperationCanceledException)
{
SerializeTimeoutException(resultData);
}
if (resultData.TryGetBuffer(out ArraySegment <byte> data))
{
await _handler.SendRawAsync(data);
return(data.Count);
}
return((int)resultData.Length);
}
private JsonRpcResponse HandleSingleRequest(JsonRpcRequest request)
{
EthWeb3RequestHandlerBase handler = _handlerResolver.Resolve(request.Method, request.Params.Length);
if (handler == null)
{
JsonRpcErrorResponse errorResponse = new JsonRpcErrorResponse {
Result = null, Error = new Error {
Code = (int)ErrorType.MethodNotFound, Data = $"{request.Method}", Message = "Method not found"
}
};
_logger.Error("Failed ETH JSON RPC request {id} {method} {params}", request.Id, request.Method, request.Params);
return(errorResponse);
}
lock (Lock)
{
object result = handler.Handle(request.Params, _web3EthApi, _jsonSerializer);
JsonRpcResponse response = new JsonRpcResponse(request, result);
_logger.Information("ETH JSON RPC request {id} {method} {params} returned {result}", request.Id, request.Method, request.Params, result);
return(response);
}
}
public void IncorrectMethodNameTest()
{
JsonRpcErrorResponse response = TestRequest(Substitute.For <IEthModule>(), "incorrect_method") as JsonRpcErrorResponse;
Assert.AreEqual(response?.Error.Code, ErrorCodes.MethodNotFound);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="method"></param>
/// <param name="id"></param>
/// <param name="args"></param>
/// <returns></returns>
public async Task <JsonRpcResponse <T> > ExecuteAsync <T>(string method, int id, params object[] args)
{
var ps = new JsonRpcRequest()
{
Method = method,
Params = args,
Id = id
};
this.OnExecuting(new EventArgs <JsonRpcRequest>(ps));
var jsonOut = JsonConvert.SerializeObject(ps.Values);
var url = this.ServiceUrl;
try
{
string jsonRet = null;
JsonRpcResponse <T> ret = null;
var request = WebRequest.CreateHttp(url);
request.ContentType = "application/json-rpc";
request.Credentials = this.GetCredentials();
request.Method = "POST";
//request.UserAgent = "LucidOcean.MultiChain {version 0}";
var bs = Encoding.UTF8.GetBytes(jsonOut);
using (var stream = await request.GetRequestStreamAsync())
{
stream.Write(bs, 0, bs.Length);
}
var response = await request.GetResponseAsync();
using (var stream = ((HttpWebResponse)response).GetResponseStream())
{
jsonRet = await new StreamReader(stream).ReadToEndAsync();
}
try
{
ret = JsonConvert.DeserializeObject <JsonRpcResponse <T> >(jsonRet);
}
catch (Exception jsonEx)
{
JsonRpcErrorResponse errorobj = JsonConvert.DeserializeObject <JsonRpcErrorResponse>(jsonRet);
throw new JsonRpcException($"({errorobj.Error.Code}) {errorobj.Error.Message}");
}
ret.Raw = jsonRet;
if (ret.Error == null && !ret.Id.HasValue && ret.Result == null)
{
ret = null;
}
return(ret);
}
catch (Exception ex) when(!(ex is JsonRpcException))
{
var nEXt = ex;
string errormsg = null;
while (nEXt != null)
{
if (nEXt is WebException)
{
var webEx = (WebException)nEXt;
if (webEx.Response != null)
{
HttpWebResponse resp = (HttpWebResponse)webEx.Response;
if (resp.StatusCode != HttpStatusCode.OK)
{
if (resp.ContentType != "application/json")
{
throw ex;
}
}
using (var stream = webEx.Response.GetResponseStream())
errormsg = new StreamReader(stream).ReadToEnd();
}
if (errormsg == null)
{
throw ex;
}
if (errormsg == "Forbidden")
{
throw ex;
}
break;
}
nEXt = nEXt.InnerException;
}
JsonRpcErrorResponse errorobj = JsonConvert.DeserializeObject <JsonRpcErrorResponse>(errormsg);
throw new JsonRpcException($"({errorobj.Error.Code}) {errorobj.Error.Message}");
}
}
