private static void Benchmark() { Console.WriteLine("Starting benchmark"); var cnt = 50; var iterations = 7; for (int iteration = 1; iteration <= iterations; iteration++) { cnt *= iteration; ctr = 0; var sw = Stopwatch.StartNew(); AutoResetEvent are = new AutoResetEvent(false); var rpcResultHandler = new AsyncCallback(_ => { if(Interlocked.Increment(ref ctr) == cnt) { sw.Stop(); Console.WriteLine("processed {0} rpc in {1}ms for {2} rpc/sec",cnt,sw.ElapsedMilliseconds, (double)cnt * 1000d / sw.ElapsedMilliseconds); are.Set(); } }); for (int i = 0; i < cnt; i++) { var async = new JsonRpcStateAsync(rpcResultHandler, null); async.JsonRpc = "{'method':'add','params':[1,2],'id':1}"; JsonRpcProcessor.Process(async); } are.WaitOne(); } Console.WriteLine("Finished benchmark..."); }
public static void Process(JsonRpcStateAsync async, object context = null) { var t = Task.Factory.StartNew((_async) => { var i = (Tuple <JsonRpcStateAsync, object>)_async; ProcessJsonRpcState(i.Item1, i.Item2); }, new Tuple <JsonRpcStateAsync, object>(async, context)); }
public static void Process(string sessionId, JsonRpcStateAsync async, object context = null) { var t = Task.Factory.StartNew((_async) => { var i = (Tuple <string, JsonRpcStateAsync, object>)_async; ProcessJsonRpcState(i.Item1, i.Item2, i.Item3); }, new Tuple <string, JsonRpcStateAsync, object>(sessionId, async, context)); }
internal static void ProcessJsonRpcState(string sessionId, JsonRpcStateAsync async, object jsonRpcContext = null) { if (string.IsNullOrEmpty(async.JsonRpc)) { async.JsonRpc = JsonConvert.SerializeObject(async.Request); } async.Result = ProcessInternal(sessionId, async.JsonRpc, jsonRpcContext); async.SetCompleted(); }
public static void Process(string sessionId, JsonRpcStateAsync async, object context = null) { var t = Task.Factory.StartNew((_async) => { var i = (Tuple<string, JsonRpcStateAsync, object>)_async; ProcessJsonRpcState(i.Item1, i.Item2, i.Item3); }, new Tuple<string, JsonRpcStateAsync, object>(sessionId, async, context)); }
public static void Process(string sessionId, JsonRpcStateAsync async, object context = null) { Process(sessionId, async.JsonRpc, context) .ContinueWith(t => { async.Result = t.Result; async.SetCompleted(); }); }
public static void Process(JsonRpcStateAsync async, object context = null) { var t = Task.Factory.StartNew((_async) => { var i = (Tuple<JsonRpcStateAsync, object>)_async; ProcessJsonRpcState(i.Item1,i.Item2); }, new Tuple<JsonRpcStateAsync,object>(async,context)); }
private static void ConsoleInput() { var rpcResultHandler = new AsyncCallback(_ => Console.WriteLine(((JsonRpcStateAsync)_).Result)); for (string line = Console.ReadLine(); !string.IsNullOrEmpty(line); line = Console.ReadLine()) { var async = new JsonRpcStateAsync(rpcResultHandler, null); async.JsonRpc = line; JsonRpcProcessor.Process(async); } }
public void Parse(ConnectionDataEventArgs e) { Log.Verbose("RPC-client recv:\n{0}", e.Data.Dump()); var rpcResultHandler = new AsyncCallback( callback => { var asyncData = ((JsonRpcStateAsync)callback); var result = asyncData.Result + "\n"; // quick hack. var client = ((RPCClient)asyncData.AsyncState); var data = Encoding.UTF8.GetBytes(result); Log.Verbose("RPC-client send:\n{0}", data.Dump()); client.Connection.Send(data); }); var line = e.Data.ToEncodedString(); line = line.Replace("\n", ""); // quick hack! var async = new JsonRpcStateAsync(rpcResultHandler, this) { JsonRpc = line }; JsonRpcProcessor.Process(async, this); }
internal static void ProcessJsonRpcState(string sessionId, JsonRpcStateAsync async, object jsonRpcContext = null) { var context = async.AsyncState; JsonRequest[] rpcBatch = null; JsonResponse[] responseBatch = null; JsonRequest rpc = null; var handler = Handler.GetSessionHandler(sessionId); var callback = string.Empty; var response = new JsonResponse(); response.Result = null; response.Error = null; string json = async.JsonRpc; if (isSingleRpc(json)) { try { if (json.Length > 0) { rpc = Newtonsoft.Json.JsonConvert.DeserializeObject <JsonRequest>(json); if (rpc == null) { response.Result = null; response.Id = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.")); } else { response.Id = rpc.Id; if (rpc.Method == null) { response.Result = null; response.Id = rpc.Id; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } } } else { response.Result = null; response.Id = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "The JSON sent is not a valid Request object.")); } } catch (Exception ex) { response.Result = null; if (rpc != null) { response.Id = rpc.Id; } response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", ex)); var result = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = result; async.SetCompleted(); return; } if (response.Error == null && rpc != null && rpc.Method != null) { var data = Handler.GetSessionHandler(sessionId).Handle(rpc, jsonRpcContext); if (data != null) { response.Error = data.Error; response.Result = data.Result; var result = ""; if (response.Id != null) // dont return a result for notifications { result = Newtonsoft.Json.JsonConvert.SerializeObject(response); } async.Result = result; async.SetCompleted(); return; } } var err = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = err; async.SetCompleted(); } else // this is a batch of requests { try { rpcBatch = Newtonsoft.Json.JsonConvert.DeserializeObject <JsonRequest[]>(json); responseBatch = new JsonResponse[rpcBatch.Length]; for (int i = 0; i < rpcBatch.Length; i++) { responseBatch[i] = new JsonResponse(); if (rpcBatch[i] == null) { responseBatch[i].Result = null; responseBatch[i].Id = null; responseBatch[i].Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.")); } else { responseBatch[i].Id = rpcBatch[i].Id; if (rpcBatch[i].Method == null) { responseBatch[i].Result = null; responseBatch[i].Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } } } } catch (Exception ex) { response.Result = null; if (rpc != null) { response.Id = rpc.Id; } response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", ex)); var result = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = result; async.SetCompleted(); return; } // we should have a batch of RPC at this point var respBuilder = new StringBuilder(); for (int i = 0; i < rpcBatch.Length; i++) { if (i == 0) { respBuilder.Append("["); } if (rpcBatch[i] == null || rpcBatch[i].Method == null) { responseBatch[i].Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } else if (responseBatch[i].Error == null) { var data = handler.Handle(rpcBatch[i], jsonRpcContext); if (data != null) { responseBatch[i].Error = data.Error; responseBatch[i].Result = data.Result; } } // dont return a response for notifications. if (responseBatch[i].Id != null || responseBatch[i].Error != null) { var result = Newtonsoft.Json.JsonConvert.SerializeObject(responseBatch[i]); respBuilder.Append(result); if (i != rpcBatch.Length - 1) { respBuilder.Append(','); } } if (i == rpcBatch.Length - 1) { respBuilder.Append("]"); var str = respBuilder.ToString(); async.Result = str; async.SetCompleted(); // let IIS think we are completed now. return; } } // if we made it this far, then there were no items in the array response.Id = null; response.Result = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(3200, "Invalid Request", "Batch of calls was empty.")); var err = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = err; async.SetCompleted(); } }
protected override async Task WorkAction() { try { var context = await this.httpListener.GetContextAsync(); var reader = new StreamReader(context.Request.InputStream, Encoding.UTF8); var line = await reader.ReadToEndAsync(); var async = new JsonRpcStateAsync(RpcResultHandler, context.Response) { JsonRpc = line }; JsonRpcProcessor.Process(async, this.rpcServer); } // ignore the exception if the worker is stopped // HttpListenerException will be thrown on SubStop catch (HttpListenerException) when (!this.IsStarted) { } finally { // always notify to continue accepting connections this.NotifyWork(); } }
/// <summary> /// Main loop of this connection handler, performing request handling as follows: /// Receive a JSON-RPC request via the socket connection. Close the connection /// in case the current service mode is DISCONNECT_BEFORE_PROCESSING. /// Otherwise, forward the request to the interceptor. Either the interceptor /// returns a response for that request, or the response is generated by handling /// the request (via the RpcTarget specified at construction time). The response /// is forwarded to the interceptor. In case the current service mode is /// DISCONNECT_BEFORE_REPLY, the connection is closed. Otherwise, the response /// is sent back via the socket to the caller. /// </summary> public void handleConnection() { // determine remote socket endpoint IPEndPoint remoteEndPoint = ((IPEndPoint)tcpClient.Client.RemoteEndPoint); Semaphore sequentialiser = new Semaphore(0, 1); try { Trace.TraceInformation("handling connection from: " + remoteEndPoint); // default service mode for a new connection is: RELIABLE ManagementService.setServiceMode(remoteEndPoint, ServiceMode.RELIABLE); NetworkStream stream = tcpClient.GetStream(); StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(false)); StreamReader reader = new StreamReader(stream, new UTF8Encoding(false)); JsonSerializer jsonSerializer = new JsonSerializer(); // main request processing loop while (ContinueConnection) { JsonRequest jsonRequest = (JsonRequest) jsonSerializer.Deserialize(reader, typeof(JsonRequest)); if (jsonRequest == null) { Trace.TraceInformation("Connection from host " + remoteEndPoint + " has been closed."); break; } String requestString = JsonConvert.SerializeObject(jsonRequest); // determine current service mode ServiceMode mode = ManagementService.getServiceMode(remoteEndPoint); // in case of RANDOM service behavior, randomly pick how to handle the current request if (mode == ServiceMode.RANDOM) { switch (rnd.Next(3)) { case 0: mode = ServiceMode.RELIABLE; break; case 1: mode = ServiceMode.DISCONNECT_BEFORE_PROCESSING; break; case 2: mode = ServiceMode.DISCONNECT_BEFORE_REPLY; break; } Trace.TraceInformation("handling request: " + requestString + " in randomly chosen mode: " + mode); } else { Trace.TraceInformation("handling request: " + requestString + " in mode: " + mode); } // simulate the case where a request is not received (and thus not processed) if (mode == ServiceMode.DISCONNECT_BEFORE_PROCESSING) { Trace.TraceInformation("explicit disconnect before processing request"); throw new IOException("explicit disconnect before processing request"); } JsonResponse jsonResponse = null; // intercept the request; might return a response to be sent back ... if (interceptor != null) jsonResponse = interceptor.interceptRequest(jsonRequest); // ... or null in case the request shall be processed in the normal way if (jsonResponse == null) { // process the request in the normal way var rpcResultHandler = new AsyncCallback( state => { var asyncState = ((JsonRpcStateAsync)state); var result = asyncState.Result; var asyncWriter = ((StreamWriter)asyncState.AsyncState); // create response from result that the handler returned jsonResponse = JsonConvert.DeserializeObject<JsonResponse>(result); // signal request handling has finished sequentialiser.Release(); }); var async = new JsonRpcStateAsync(rpcResultHandler, writer) { JsonRpc = requestString }; JsonRpcProcessor.Process(async, writer); // sequentialise all requests, avoiding any potential conflicts resulting // from concurrent request handling, such as for instance mixing up reply // messages; wait for request to be completed sequentialiser.WaitOne(); } // intercept the response (even in case it was a stored response // returned by the request interceptor) if (interceptor != null) interceptor.interceptResponse(jsonRequest, jsonResponse); // simulate the case where the request has been processed, but the // reply could not be sent back if (mode == ServiceMode.DISCONNECT_BEFORE_REPLY) { Trace.TraceInformation("explicit disconnect before sending reply"); throw new IOException("explicit disconnect before sending reply"); } // send back reply String responseString = JsonConvert.SerializeObject(jsonResponse); writer.Write(responseString); writer.Flush(); } } catch (IOException) { Trace.TraceInformation("closing connection with: " + remoteEndPoint); } catch (Exception e) { Trace.TraceError("RPCServer exception " + e); } finally { tcpClient.Close(); } }
public static void Process(JsonRpcStateAsync async, object context = null) { Process(Handler.DefaultSessionId(), async, context); }
/// <summary> /// Parses the incoming data. /// </summary> /// <param name="e"></param> public void Parse(ConnectionDataEventArgs e) { Log.Verbose("RPC-client recv:\n{0}", e.Data.ToEncodedString()); var rpcResultHandler = new AsyncCallback( callback => { var asyncData = ((JsonRpcStateAsync)callback); var result = asyncData.Result + "\n"; // quick hack. var response = Encoding.UTF8.GetBytes(result); var context = (SocketsRpcContext) asyncData.AsyncState; var miner = (StratumMiner)context.Miner; miner.Connection.Send(response); Log.Verbose("RPC-client send:\n{0}", result); }); var line = e.Data.ToEncodedString(); line = line.Replace("\n", ""); // quick hack! var rpcRequest = new SocketsRpcRequest(line); var rpcContext = new SocketsRpcContext(this, rpcRequest); var async = new JsonRpcStateAsync(rpcResultHandler, rpcContext) { JsonRpc = line }; JsonRpcProcessor.Process(async, rpcContext); }
internal static void ProcessJsonRpcState(string sessionId, JsonRpcStateAsync async, object jsonRpcContext = null) { async.Result = ProcessInternal(sessionId, async.JsonRpc, jsonRpcContext); async.SetCompleted(); }
internal static void ProcessJsonRpcState(string sessionId, JsonRpcStateAsync async, object jsonRpcContext = null) { var context = async.AsyncState; JsonRequest[] rpcBatch = null; JsonResponse[] responseBatch = null; JsonRequest rpc = null; var handler = Handler.GetSessionHandler(sessionId); var callback = string.Empty; var response = new JsonResponse(); response.Result = null; response.Error = null; string json = async.JsonRpc; if (isSingleRpc(json)) { try { if (json.Length > 0) { rpc = Newtonsoft.Json.JsonConvert.DeserializeObject<JsonRequest>(json); if (rpc == null) { response.Result = null; response.Id = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.")); } else { response.Id = rpc.Id; if (rpc.Method == null) { response.Result = null; response.Id = rpc.Id; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } } } else { response.Result = null; response.Id = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "The JSON sent is not a valid Request object.")); } } catch (Exception ex) { response.Result = null; if (rpc != null) response.Id = rpc.Id; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", ex)); var result = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = result; async.SetCompleted(); return; } if (response.Error == null && rpc != null && rpc.Method != null) { var data = Handler.GetSessionHandler(sessionId).Handle(rpc, jsonRpcContext); if (data != null) { response.Error = data.Error; response.Result = data.Result; var result = ""; if (response.Id != null)// dont return a result for notifications { result=Newtonsoft.Json.JsonConvert.SerializeObject(response); } async.Result = result; async.SetCompleted(); return; } } var err = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = err; async.SetCompleted(); } else // this is a batch of requests { try { rpcBatch = Newtonsoft.Json.JsonConvert.DeserializeObject<JsonRequest[]>(json); responseBatch = new JsonResponse[rpcBatch.Length]; for (int i = 0; i < rpcBatch.Length; i++) { responseBatch[i] = new JsonResponse(); if (rpcBatch[i] == null) { responseBatch[i].Result = null; responseBatch[i].Id = null; responseBatch[i].Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.")); } else { responseBatch[i].Id = rpcBatch[i].Id; if (rpcBatch[i].Method == null) { responseBatch[i].Result = null; responseBatch[i].Error =handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } } } } catch (Exception ex) { response.Result = null; if (rpc != null) response.Id = rpc.Id; response.Error = handler.ProcessParseException(json, new JsonRpcException(-32700, "Parse error", ex)); var result = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = result; async.SetCompleted(); return; } // we should have a batch of RPC at this point var respBuilder = new StringBuilder(); for (int i = 0; i < rpcBatch.Length; i++) { if (i == 0) { respBuilder.Append("["); } if (rpcBatch[i] == null || rpcBatch[i].Method == null) { responseBatch[i].Error = handler.ProcessParseException(json, new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'")); } else if (responseBatch[i].Error == null) { var data = handler.Handle(rpcBatch[i], jsonRpcContext); if (data != null) { responseBatch[i].Error = data.Error; responseBatch[i].Result = data.Result; } } // dont return a response for notifications. if (responseBatch[i].Id != null || responseBatch[i].Error != null) { var result = Newtonsoft.Json.JsonConvert.SerializeObject(responseBatch[i]); respBuilder.Append(result); if (i != rpcBatch.Length - 1) { respBuilder.Append(','); } } if (i == rpcBatch.Length - 1) { respBuilder.Append("]"); var str = respBuilder.ToString(); async.Result = str; async.SetCompleted(); // let IIS think we are completed now. return; } } // if we made it this far, then there were no items in the array response.Id = null; response.Result = null; response.Error = handler.ProcessParseException(json, new JsonRpcException(3200, "Invalid Request", "Batch of calls was empty.")); var err = Newtonsoft.Json.JsonConvert.SerializeObject(response); async.Result = err; async.SetCompleted(); } }
public void Parse(HttpListenerContext httpContext) { try { var httpRequest = httpContext.Request; using (var reader = new StreamReader(httpRequest.InputStream, Encoding.UTF8)) { var line = reader.ReadToEnd(); var rpcContext = new GetworkContext(this, httpContext); _packetLogger.Verbose("rx: {0}", line.PrettifyJson()); var async = new JsonRpcStateAsync(_rpcResultHandler, rpcContext) {JsonRpc = line}; JsonRpcProcessor.Process(Pool.Config.Coin.Name, async, rpcContext); } } catch (JsonReaderException e) // if client sent an invalid message { _logger.Error("Skipping invalid json-rpc request - {0:l}", e.Message); } }
internal static void ProcessJsonRpcState(string sessionId, JsonRpcStateAsync async, object jsonRpcContext = null) { async.Result = ProcessInternal(sessionId, async.JsonRpc, jsonRpcContext); async.SetCompleted(); }
/// <summary> /// Parses the incoming data. /// </summary> /// <param name="e"></param> public void Parse(ConnectionDataEventArgs e) { _logger.Verbose("rx: {0}", e.Data.ToEncodedString().PrettifyJson()); var rpcResultHandler = new AsyncCallback( callback => { var asyncData = ((JsonRpcStateAsync)callback); var result = asyncData.Result + "\n"; var response = Encoding.UTF8.GetBytes(result); var context = (SocketServiceContext) asyncData.AsyncState; var miner = (StratumMiner)context.Miner; miner.Connection.Send(response); _logger.Verbose("tx: {0}", result.PrettifyJson()); }); var line = e.Data.ToEncodedString(); line = line.Replace("\n", ""); var rpcRequest = new SocketServiceRequest(line); var rpcContext = new SocketServiceContext(this, rpcRequest); var async = new JsonRpcStateAsync(rpcResultHandler, rpcContext) { JsonRpc = line }; JsonRpcProcessor.Process(Pool.Config.Coin.Name, async, rpcContext); }
public void Parse(HttpListenerContext httpContext) { var httpRequest = httpContext.Request; var encoding = Encoding.UTF8; var rpcResultHandler = new AsyncCallback( callback => { var asyncData = ((JsonRpcStateAsync) callback); var result = asyncData.Result; var data = Encoding.UTF8.GetBytes(result); var request = ((HttpRpcResponse) asyncData.AsyncState); request.Response.ContentType = "application/json"; request.Response.ContentEncoding = encoding; request.Response.ContentLength64 = data.Length; request.Response.OutputStream.Write(data,0,data.Length); }); using (var reader = new StreamReader(httpRequest.InputStream, encoding)) { var line = reader.ReadToEnd(); Log.Verbose(line.PretifyJson()); var response = httpContext.Response; var rpcResponse = new HttpRpcResponse(line, response); var rpcContext = new HttpRpcContext(this, rpcResponse); var async = new JsonRpcStateAsync(rpcResultHandler, rpcResponse) { JsonRpc = line }; JsonRpcProcessor.Process(async, rpcContext); } }
public static void Process(JsonRpcStateAsync async, object context = null, JsonSerializerSettings settings = null) { Process(Handler.DefaultSessionId(), async, context, settings); }
internal static void ProcessJsonRpcState(JsonRpcStateAsync async, object jsonRpcContext = null) { ProcessJsonRpcState(Handler.DefaultSessionId(), async, jsonRpcContext); }
public void Parse(HttpListenerContext httpContext) { var httpRequest = httpContext.Request; var rpcResultHandler = new AsyncCallback( callback => { var asyncData = ((JsonRpcStateAsync) callback); var result = asyncData.Result; var response = Encoding.UTF8.GetBytes(result); var context = (HttpServiceContext)asyncData.AsyncState; context.Request.Response.ContentType = "application/json"; context.Request.Response.ContentEncoding = Encoding.UTF8; context.Request.Response.ContentLength64 = response.Length; context.Request.Response.OutputStream.Write(response, 0, response.Length); }); using (var reader = new StreamReader(httpRequest.InputStream, Encoding.UTF8)) { var line = reader.ReadToEnd(); Log.ForContext<VanillaMiner>().Verbose(line.PrettifyJson()); var rpcRequest = new HttpServiceRequest(line, httpContext); var rpcContext = new HttpServiceContext(this, rpcRequest); var async = new JsonRpcStateAsync(rpcResultHandler, rpcContext) { JsonRpc = line }; JsonRpcProcessor.Process(async, rpcContext); } }
private void ProcessRequest(string line) { try { var rpcContext = new StratumContext(this); // set the context. _packetLogger.Verbose("rx: {0}", line.PrettifyJson()); var async = new JsonRpcStateAsync(_rpcResultHandler, rpcContext) {JsonRpc = line}; JsonRpcProcessor.Process(Pool.Config.Coin.Name, async, rpcContext); } catch (JsonReaderException e) // if client sent an invalid message { _logger.Error("Disconnecting miner {0:l} as we recieved an invalid json-rpc request - {1:l}", Username ?? Connection.RemoteEndPoint.ToString(), e.Message); Connection.Disconnect(); // disconnect him. } }
internal static void ProcessJsonRpcState(JsonRpcStateAsync async, object jsonRpcContext = null) { ProcessJsonRpcState(Handler.DefaultSessionId(), async, jsonRpcContext); }