public override BizContext preHandleRequest(RemotingContext remotingCtx, object request) { BizContext ctx = new MyBizContext(this, remotingCtx); ctx.put("test", "test"); return(ctx); }
/// <summary> /// Handle the request(s). /// </summary> /// <param name="ctx"></param> /// <param name="msg"></param> private void handle(RemotingContext ctx, object msg) { try { if (msg is IList) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Runnable handleTask = new Runnable() Runnable handleTask = new TempRunnable(this, ctx, msg); if (RpcConfigManager.dispatch_msg_list_in_default_executor()) { // If msg is list ,then the batch submission to biz threadpool can save io thread. // See decoder.ProtocolDecoder processorManager.DefaultExecutor.execute(handleTask); } else { handleTask.run(); } } else { process(ctx, msg); } } catch (System.Exception t) { processException(ctx, msg, t); } }
public async Task Invoke(HttpContext context, StatelessServiceContext serviceContext) { using (_logger.BeginScope(new Dictionary <string, object> { [SharedProperties.TraceId] = context.Request.HttpContext.TraceIdentifier })) { RemotingContext.SetData(HeaderIdentifiers.TraceId, context.Request.HttpContext.TraceIdentifier); AddTracingDetailsOnRequest(context, serviceContext); var stopwatch = Stopwatch.StartNew(); var started = DateTime.Now; var success = false; try { await _next(context); success = true; } catch (Exception exception) { _logger.LogCritical((int)ServiceFabricEvent.Exception, exception, exception.Message); throw; } finally { stopwatch.Stop(); _logger.LogRequest(context, started, stopwatch.Elapsed, success); } } }
/// <summary> /// pre process remoting context, initial some useful infos and pass to biz /// </summary> /// <param name="ctx"> remoting context </param> /// <param name="cmd"> rpc request command </param> /// <param name="currentTimestamp"> current timestamp </param> private void preProcessRemotingContext(RemotingContext ctx, RpcRequestCommand cmd, long currentTimestamp) { ctx.ArriveTimestamp = cmd.ArriveTime; ctx.Timeout = cmd.Timeout; ctx.RpcCommandType = cmd.Type; ctx.InvokeContext.putIfAbsent(InvokeContext.BOLT_PROCESS_WAIT_TIME, currentTimestamp - cmd.ArriveTime); }
/// <seealso cref= AbstractRemotingProcessor#doProcess </seealso> public override void doProcess(RemotingContext ctx, RemotingCommand cmd) { Connection conn = ctx.ChannelContext.Channel.GetAttribute(Connection.CONNECTION).Get(); InvokeFuture future = conn.removeInvokeFuture(cmd.Id); try { if (future != null) { future.putResponse(cmd); future.cancelTimeout(); try { future.executeInvokeCallback(); } catch (System.Exception e) { logger.LogError("Exception caught when executing invoke callback, id={}", cmd.Id, e); } } else { logger.LogWarning("Cannot find InvokeFuture, maybe already timeout, id={}, from={} ", cmd.Id, ctx.ChannelContext.Channel.RemoteAddress.ToString()); } } finally { } }
/// <summary> /// print some debug log when receive request /// </summary> private void debugLog(RemotingContext ctx, RpcRequestCommand cmd, long currentTimestamp) { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("Rpc request received! requestId={}, from {}", cmd.Id, ctx.ChannelContext.Channel.RemoteAddress.ToString()); logger.LogDebug("request id {} currenTimestamp {} - arriveTime {} = server cost {} < timeout {}.", cmd.Id, currentTimestamp, cmd.ArriveTime, currentTimestamp - cmd.ArriveTime, cmd.Timeout); } }
Task <int> IMyActor.GetCountAsync(CancellationToken cancellationToken) { var traceId = RemotingContext.GetData(HeaderIdentifiers.TraceId); _logger.LogInformation($"Hello from inside {nameof(MyActor)} (traceId {traceId})"); return(StateManager.GetStateAsync <int>("count", cancellationToken)); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: @Override public void doProcess(final RemotingContext ctx, RemotingCommand msg) public override void doProcess(RemotingContext ctx, RemotingCommand msg) { if (msg is HeartbeatCommand) { // process the heartbeat //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int id = msg.getId(); int id = msg.Id; if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("Heartbeat received! Id=" + id + ", from " + ctx.ChannelContext.Channel.RemoteAddress.ToString()); } HeartbeatAckCommand ack = new HeartbeatAckCommand(); ack.Id = id; var writeFlushTask = ctx.writeAndFlush(ack); writeFlushTask.ContinueWith((task) => { if (task.IsCompletedSuccessfully) { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("Send heartbeat ack done! Id={}, to remoteAddr={}", id, ctx.ChannelContext.Channel.RemoteAddress.ToString()); } } else { logger.LogError("Send heartbeat ack failed! Id={}, to remoteAddr={}", id, ctx.ChannelContext.Channel.RemoteAddress.ToString()); } }); //.addListener(new ChannelFutureListenerAnonymousInnerClass(this, ctx, id)); } else if (msg is HeartbeatAckCommand) { Connection conn = (Connection)ctx.ChannelContext.Channel.GetAttribute(Connection.CONNECTION).Get(); InvokeFuture future = conn.removeInvokeFuture(msg.Id); if (future != null) { future.putResponse(msg); future.cancelTimeout(); try { future.executeInvokeCallback(); } catch (Exception e) { logger.LogError("Exception caught when executing heartbeat invoke callback. From {}", ctx.ChannelContext.Channel.RemoteAddress.ToString(), e); } } else { logger.LogWarning("Cannot find heartbeat InvokeFuture, maybe already timeout. Id={}, From {}", msg.Id, ctx.ChannelContext.Channel.RemoteAddress.ToString()); } } else { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new Exception("Cannot process command: " + msg.GetType().FullName); } }
/// <summary> /// Send response using remoting context if necessary.<br> /// If request type is oneway, no need to send any response nor exception. /// </summary> /// <param name="ctx"> remoting context </param> /// <param name="type"> type code </param> /// <param name="response"> remoting command </param> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public void sendResponseIfNecessary(final RemotingContext ctx, byte type, final RemotingCommand response) public virtual void sendResponseIfNecessary(RemotingContext ctx, byte type, RemotingCommand response) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int id = response.getId(); int id = response.Id; if (type != RpcCommandType.REQUEST_ONEWAY) { RemotingCommand serializedResponse = response; try { response.serialize(); } catch (SerializationException e) { string errMsg = "SerializationException occurred when sendResponseIfNecessary in RpcRequestProcessor, id=" + id; logger.LogError(errMsg, e); serializedResponse = CommandFactory.createExceptionResponse(id, ResponseStatus.SERVER_SERIAL_EXCEPTION, e); try { serializedResponse.serialize(); // serialize again for exception response } catch (SerializationException) { // should not happen logger.LogError("serialize SerializationException response failed!"); } } catch (System.Exception t) { string errMsg = "Serialize RpcResponseCommand failed when sendResponseIfNecessary in RpcRequestProcessor, id=" + id; logger.LogError(errMsg, t); serializedResponse = CommandFactory.createExceptionResponse(id, t, errMsg); } var writeFlushTask = ctx.writeAndFlush(serializedResponse); writeFlushTask.ContinueWith((task) => { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("Rpc response sent! requestId=" + id + ". The address is " + ctx.ChannelContext.Channel.RemoteAddress.ToString()); } if (!task.IsCompletedSuccessfully) { logger.LogError("Rpc response send failed! id=" + id + ". The address is " + ctx.ChannelContext.Channel.RemoteAddress.ToString(), task.Exception); } }); //.addListener(new ChannelFutureListenerAnonymousInnerClass(this, ctx, id)); } else { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("Oneway rpc request received, do not send response, id=" + id + ", the address is " + ctx.ChannelContext.Channel.RemoteAddress.ToString()); } } }
Task <string> IDemoActor.GetGreetingResponseAsync(CancellationToken cancellationToken) { // Read the data from the custom header var remotingContext = string.Join(", ", RemotingContext.Keys.Select(k => $"{k}: {RemotingContext.GetData(k)}")); ActorEventSource.Current.ActorMessage(this, $"GetGreetingResponseAsync got context: {remotingContext}"); return(Task.FromResult($"Hello From Actor (with context '{remotingContext}')")); }
public async Task <int> CalculateSumAsync(int a, int b) { var traceId = RemotingContext.GetData(HeaderIdentifiers.TraceId); _logger.LogTrace($"Hello from inside {nameof(MyStateless)} (traceId {traceId})"); await new HttpClient().GetAsync("http://www.nu.nl"); return(a + b); }
public Startup(IWebHostEnvironment env) { Environment = env; var dom = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .AddEnvironmentVariables() .Build(); Configuration = dom; RemotingContext.Set(Environment, Configuration); ASP_DBEntities.ConnectionString = Configuration["ASP_DBEntities"]; // globally }
/// <summary> /// dispatch request command to user processor /// </summary> /// <param name="ctx"> remoting context </param> /// <param name="cmd"> rpc request command </param> private void dispatchToUserProcessor(RemotingContext ctx, RpcRequestCommand cmd) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int id = cmd.getId(); int id = cmd.Id; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final byte type = cmd.getType(); byte type = cmd.Type; // processor here must not be null, for it have been checked before UserProcessor processor = ctx.getUserProcessor(cmd.RequestClass); if (processor is AsyncUserProcessor) { try { processor.handleRequest(processor.preHandleRequest(ctx, cmd.RequestObject), new RpcAsyncContext(ctx, cmd, this), cmd.RequestObject); } catch (RejectedExecutionException) { logger.LogWarning("RejectedExecutionException occurred when do ASYNC process in RpcRequestProcessor"); sendResponseIfNecessary(ctx, type, CommandFactory.createExceptionResponse(id, ResponseStatus.SERVER_THREADPOOL_BUSY)); } catch (System.Exception t) { string errMsg = "AYSNC process rpc request failed in RpcRequestProcessor, id=" + id; logger.LogError(errMsg, t); sendResponseIfNecessary(ctx, type, CommandFactory.createExceptionResponse(id, t, errMsg)); } } else { try { object responseObject = processor.handleRequest(processor.preHandleRequest(ctx, cmd.RequestObject), cmd.RequestObject); sendResponseIfNecessary(ctx, type, CommandFactory.createResponse(responseObject, cmd)); } catch (RejectedExecutionException) { logger.LogWarning("RejectedExecutionException occurred when do SYNC process in RpcRequestProcessor"); sendResponseIfNecessary(ctx, type, CommandFactory.createExceptionResponse(id, ResponseStatus.SERVER_THREADPOOL_BUSY)); } catch (System.Exception t) { string errMsg = "SYNC process rpc request failed in RpcRequestProcessor, id=" + id; logger.LogError(errMsg, t); sendResponseIfNecessary(ctx, type, CommandFactory.createExceptionResponse(id, t, errMsg)); } } }
public async Task <string> SayHelloToActor() { // Read the data from the custom header var remotingContext = string.Join(", ", RemotingContext.Keys.Select(k => $"{k}: {RemotingContext.GetData(k)}")); ServiceEventSource.Current.ServiceMessage(Context, $"SayHelloToActor got context: {remotingContext}"); // Call the actor using the same headers as received by this method var proxy = ExtendedActorProxy.Create <IDemoActor>(new ActorId(1), CustomHeaders.FromRemotingContext); var response = await proxy.GetGreetingResponseAsync(CancellationToken.None); return($"DemoService passed context '{remotingContext}' to actor and got as response: {response}"); }
private void processException(RemotingContext ctx, object msg, System.Exception t) { if (msg is IList) { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (final Object m : (java.util.List<object><?>) msg) foreach (var m in (IList <object>)msg) { processExceptionForSingleCommand(ctx, m, t); } } else { processExceptionForSingleCommand(ctx, msg, t); } }
/// <inheritdoc/> public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { var handleExtended = false; Uri serviceUri = null; object state = null; Exception exception = null; var header = requestMessage.GetHeader() as IActorRemotingMessageHeaders; //check to see if message headers are assignable if (header != null) { handleExtended = true; serviceUri = (Uri)header.GetCustomHeaders()[CustomHeaders.ReservedHeaderServiceUri]; RemotingContext.FromRemotingMessageHeader(header); } if (BeforeHandleRequestResponseAsync != null && handleExtended) { state = await BeforeHandleRequestResponseAsync.Invoke(new ActorRequestInfo(requestMessage, header.ActorId, header.MethodName, serviceUri)); } IServiceRemotingResponseMessage responseMessage = null; try { responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage); } catch (Exception ex) { exception = ex; throw; } finally { if (AfterHandleRequestResponseAsync != null && handleExtended) { await AfterHandleRequestResponseAsync.Invoke(new ActorResponseInfo(responseMessage, header.ActorId, header.MethodName, serviceUri, state, exception)); } } return(responseMessage); }
/// <seealso cref= AbstractRemotingProcessor#doProcess(RemotingContext, RemotingCommand) </seealso> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings({ "rawtypes", "unchecked" }) @Override public void doProcess(final RemotingContext ctx, RpcRequestCommand cmd) throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: public virtual void doProcess(RemotingContext ctx, RpcRequestCommand cmd) { long currentTimestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds(); preProcessRemotingContext(ctx, cmd, currentTimestamp); if (ctx.TimeoutDiscard && ctx.RequestTimeout) { timeoutLog(cmd, currentTimestamp, ctx); // do some log return; // then, discard this request } debugLog(ctx, cmd, currentTimestamp); // decode request all if (!deserializeRequestCommand(ctx, cmd, RpcDeserializeLevel.DESERIALIZE_ALL)) { return; } dispatchToUserProcessor(ctx, cmd); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings({ "rawtypes", "unchecked" }) private void process(RemotingContext ctx, Object msg) private void process(RemotingContext ctx, object msg) { try { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final rpc.RpcCommand cmd = (rpc.RpcCommand) msg; RpcCommand cmd = (RpcCommand)msg; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final RemotingProcessor processor = processorManager.getProcessor(cmd.getCmdCode()); var processor = processorManager.getProcessor(cmd.CmdCode); processor.process(ctx, cmd, processorManager.DefaultExecutor); } //JAVA TO C# CONVERTER WARNING: 'final' catch parameters are not available in C#: //ORIGINAL LINE: catch (final Throwable t) catch (System.Exception t) { processException(ctx, msg, t); } }
/// <summary> /// print some log when request timeout and discarded in io thread. /// </summary> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: private void timeoutLog(final RpcRequestCommand cmd, long currentTimestamp, RemotingContext ctx) private void timeoutLog(RpcRequestCommand cmd, long currentTimestamp, RemotingContext ctx) { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug("request id [{}] currenTimestamp [{}] - arriveTime [{}] = server cost [{}] >= timeout value [{}].", cmd.Id, currentTimestamp, cmd.ArriveTime, currentTimestamp - cmd.ArriveTime, cmd.Timeout); } string remoteAddr = "UNKNOWN"; if (null != ctx) { IChannelHandlerContext channelCtx = ctx.ChannelContext; IChannel channel = channelCtx.Channel; if (null != channel) { remoteAddr = ((IPEndPoint)channel.RemoteAddress).ToString(); } } logger.LogWarning("Rpc request id[{}], from remoteAddr[{}] stop process, total wait time in queue is [{}], client timeout setting is [{}].", cmd.Id, remoteAddr, currentTimestamp - cmd.ArriveTime, cmd.Timeout); }
/* * Return error command if necessary. */ private void processExceptionForSingleCommand(RemotingContext ctx, object msg, System.Exception t) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int id = ((rpc.RpcCommand) msg).getId(); int id = ((RpcCommand)msg).Id; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String emsg = "Exception caught when processing " + ((msg instanceof rpc.RequestCommand) ? "request, id=" : "response, id="); string emsg = "Exception caught when processing " + ((msg is RequestCommand) ? "request, id=" : "response, id="); logger.LogWarning(emsg + id, t); if (msg is RequestCommand) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final rpc.RequestCommand cmd = (rpc.RequestCommand) msg; RequestCommand cmd = (RequestCommand)msg; if (cmd.Type != RpcCommandType.REQUEST_ONEWAY) { if (t is RejectedExecutionException) { ResponseCommand response = (ResponseCommand)commandFactory.createExceptionResponse(id, ResponseStatus.SERVER_THREADPOOL_BUSY); var task = ctx.ChannelContext.WriteAndFlushAsync(response); task.ContinueWith((writeFlushTask) => { if (writeFlushTask.IsCompletedSuccessfully) { if (logger.IsEnabled(LogLevel.Information)) { logger.LogInformation("Write back exception response done, requestId={}, status={}", id, response.ResponseStatus); } } else { logger.LogError("Write back exception response failed, requestId={}", id, writeFlushTask.Exception); } }); } } } }
/// <inheritdoc/> public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { var header = requestMessage.GetHeader(); var serviceUri = (Uri)header.GetCustomHeaders()[CustomHeaders.ReservedHeaderServiceUri]; RemotingContext.FromRemotingMessageHeader(header); object state = null; Exception exception = null; if (BeforeHandleRequestResponseAsync != null) { state = await BeforeHandleRequestResponseAsync.Invoke(new ServiceRequestInfo(requestMessage, header.MethodName, serviceUri)); } IServiceRemotingResponseMessage responseMessage = null; try { responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage); } catch (Exception ex) { exception = ex; throw; } finally { if (AfterHandleRequestResponseAsync != null) { await AfterHandleRequestResponseAsync.Invoke(new ServiceResponseInfo(responseMessage, header.MethodName, serviceUri, state, exception)); } } return(responseMessage); }
/// <summary> /// deserialize request command /// </summary> /// <returns> true if deserialize success; false if exception catched </returns> private bool deserializeRequestCommand(RemotingContext ctx, RpcRequestCommand cmd, int level) { bool result; try { cmd.deserialize(level); result = true; } catch (DeserializationException e) { logger.LogError("DeserializationException occurred when process in RpcRequestProcessor, id={}, deserializeLevel={}", cmd.Id, RpcDeserializeLevel.valueOf(level), e); sendResponseIfNecessary(ctx, cmd.Type, CommandFactory.createExceptionResponse(cmd.Id, ResponseStatus.SERVER_DESERIAL_EXCEPTION, e)); result = false; } catch (System.Exception t) { string errMsg = "Deserialize RpcRequestCommand failed in RpcRequestProcessor, id=" + cmd.Id + ", deserializeLevel=" + level; logger.LogError(errMsg, t); sendResponseIfNecessary(ctx, cmd.Type, CommandFactory.createExceptionResponse(cmd.Id, t, errMsg)); result = false; } return(result); }
public ProcessTask(RpcRequestProcessor outerInstance, RemotingContext ctx, RpcRequestCommand msg) { this.outerInstance = outerInstance; this.ctx = ctx; this.msg = msg; }
/// <inheritdoc/> public override void HandleOneWayMessage(IServiceRemotingRequestMessage requestMessage) { RemotingContext.FromRemotingMessageHeader(requestMessage.GetHeader()); base.HandleOneWayMessage(requestMessage); }
/// <seealso cref= CommandHandler#handleCommand(RemotingContext, Object) </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public void handleCommand(RemotingContext ctx, Object msg) throws Exception public virtual void handleCommand(RemotingContext ctx, object msg) { handle(ctx, msg); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public void doProcess(RemotingContext ctx, RemotingCommand msg) throws Exception public override void doProcess(RemotingContext ctx, RemotingCommand msg) { logger.LogError("No processor available for command code {}, msgId {}", msg.CmdCode, msg.Id); }
public TempRunnable(RpcCommandHandler rpcCommandHandler, RemotingContext remotingContext, object msg) { this.rpcCommandHandler = rpcCommandHandler; this.remotingContext = remotingContext; this.msg = msg; }
/// <summary> /// Constructor /// </summary> /// <param name="remotingCtx"> </param> public MyBizContext(PreHandleUserProcessor outerInstance, RemotingContext remotingCtx) : base(remotingCtx) { this.outerInstance = outerInstance; }
public ILoggerFactory CreateLoggerFactory(string aiKey) { var configuration = new TelemetryConfiguration { InstrumentationKey = aiKey }; configuration.TelemetryInitializers.Add(new OperationContextTelemetryInitializer(() => RemotingContext.GetData(HeaderIdentifiers.TraceId)?.ToString())); new LiveStreamProvider(configuration).Enable(); var loggerFactory = new LoggerFactory(); var logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo .ApplicationInsights( configuration, (logEvent, formatter) => new TelemetryBuilder(_context, logEvent).LogEventToTelemetryConverter()) .CreateLogger(); InitContextProperties(); loggerFactory.AddSerilog(logger, true); return(loggerFactory); }
/// <seealso cref= AbstractRemotingProcessor#process(RemotingContext, RemotingCommand, java.util.concurrent.ExecutorService) </seealso> public override void process(RemotingContext ctx, RemotingCommand cmd, ExecutorService defaultExecutor) { var rpcRequestCommand = (RpcRequestCommand)cmd; if (!deserializeRequestCommand(ctx, rpcRequestCommand, RpcDeserializeLevel.DESERIALIZE_CLAZZ)) { return; } UserProcessor userProcessor = ctx.getUserProcessor(rpcRequestCommand.RequestClass); if (userProcessor == null) { string errMsg = "No user processor found for request: " + rpcRequestCommand.RequestClass; logger.LogError(errMsg); sendResponseIfNecessary(ctx, rpcRequestCommand.Type, CommandFactory.createExceptionResponse(cmd.Id, errMsg)); return; // must end process } // set timeout check state from user's processor ctx.setTimeoutDiscard(userProcessor.timeoutDiscard()); // to check whether to process in io thread if (userProcessor.processInIOThread()) { if (!deserializeRequestCommand(ctx, rpcRequestCommand, RpcDeserializeLevel.DESERIALIZE_ALL)) { return; } // process in io thread new ProcessTask(this, ctx, rpcRequestCommand).run(); return; // end } Executor executor; // to check whether get executor using executor selector if (null == userProcessor.ExecutorSelector) { executor = userProcessor.Executor; } else { // in case haven't deserialized in io thread // it need to deserialize clazz and header before using executor dispath strategy if (!deserializeRequestCommand(ctx, rpcRequestCommand, RpcDeserializeLevel.DESERIALIZE_HEADER)) { return; } //try get executor with strategy executor = userProcessor.ExecutorSelector.select(rpcRequestCommand.RequestClass, rpcRequestCommand.RequestHeader); } // Till now, if executor still null, then try default if (executor == null) { executor = Executor ?? defaultExecutor; } // use the final executor dispatch process task executor.execute(new ProcessTask(this, ctx, rpcRequestCommand)); }