/// <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); }
private RpcRequestCommand createRequestCommand(short cmdCode) { RpcRequestCommand command = new RpcRequestCommand(); command.CmdCode = RpcCommandCode.valueOf(cmdCode); command.ArriveTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds(); return(command); }
/// <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); } }
/// <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)); } } }
/// <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); }
/// <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); }
/// <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; }
/// <summary> /// Default constructor. /// </summary> /// <param name="ctx"> remoting context </param> /// <param name="cmd"> rpc request command </param> /// <param name="processor"> rpc request processor </param> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public RpcAsyncContext(final RemotingContext ctx, final RpcRequestCommand cmd, final RpcRequestProcessor processor) public RpcAsyncContext(RemotingContext ctx, RpcRequestCommand cmd, RpcRequestProcessor processor) { this.ctx = ctx; this.cmd = cmd; this.processor = processor; }