private void ReturnInner <T>(RpcResponseHeader response, T results)
{
try {
if (Interlocked.CompareExchange(ref _hasReturned, 1, 0) != 0)
{
string msg = string.Format("Return more than once <{0}.{1}>", this.ServiceName, this.MethodName);
throw new NotSupportedException(msg);
}
TracingManager.Info(
delegate() {
_observer.ResponseTracer.InfoFmt2(
_request.FromService + "@" + _request.FromComputer,
_request.ToUri,
"Args={0}\r\nResults={1}",
ObjectHelper.DumpObject(_args),
ObjectHelper.DumpObject(results)
);
}
);
_trans.SendResponse(response, results);
_observer.Track(true, response.Error, (int)_watch.ElapsedMilliseconds);
} catch (Exception innerEx) {
SystemLog.Error(LogEventID.RpcFailed, innerEx, "RpcServerContext.ReturnError Failed");
} finally {
_perfCounters.ConcurrentContext.Decrement();
_perfCounters.InvokeFailed.Increment();
}
}
private void ReturnError(RpcResponseHeader response)
{
try {
if (Interlocked.CompareExchange(ref _hasReturned, 1, 0) != 0)
{
string msg = string.Format("Return more than once <{0}.{1}> ex={2}", this.ServiceName, this.MethodName, response.Error);
throw new NotSupportedException(msg);
}
_observer.ResponseTracer.ErrorFmt2(
response.Error,
_request.FromService + "@" + _request.FromComputer,
_request.ToUri,
"Args={0}",
ObjectHelper.DumpObject(_args)
);
_trans.SendError(response);
_observer.Track(false, response.Error, _watch.ElapsedTicks);
} catch (Exception innerEx) {
SystemLog.Error(LogEventID.RpcFailed, innerEx, "RpcServerContext.ReturnError Failed");
} finally {
_perfCounters.ConcurrentContext.Decrement();
_perfCounters.InvokeFailed.Increment();
}
}
protected virtual void OnExecute(IClientContext client, Stream input, Stream output)
{
RpcRequestHeader requestHeader = RpcRequestHeader.DefaultInstance;
RpcResponseHeader.Builder responseHeader = RpcResponseHeader.CreateBuilder();
try
{
requestHeader = RpcRequestHeader.ParseDelimitedFrom(input, ExtensionRegistry);
responseHeader.SetMessageId(requestHeader.MessageId);
IMessageLite responseBody = OnExecute(client, requestHeader, CodedInputStream.CreateInstance(input),
responseHeader);
responseHeader.Build().WriteDelimitedTo(output);
responseBody.WriteTo(output);
}
catch (Exception ex)
{
OnException(requestHeader, responseHeader, ex);
responseHeader.Build().WriteDelimitedTo(output);
}
}
protected virtual void CallService(RpcRequestHeader requestHeader, IMessageLite requestBody,
out RpcResponseHeader responseHeader, out Stream responseBody)
{
byte[] requestBytes;
using (MemoryStream input = new MemoryStream(1024))
{
requestHeader.WriteDelimitedTo(input);
requestBody.WriteTo(input);
requestBytes = input.ToArray();
}
Stream output = Execute(requestBytes);
try
{
responseHeader = RpcResponseHeader.ParseDelimitedFrom(output, ExtensionRegistry);
responseBody = output;
}
catch
{
output.Dispose();
throw;
}
}
public void ThrowException(Exception ex)
{
var response = RpcResponseHeader.CreateError(RpcErrorCode.ServerError, ex);
ReturnError(response);
}
public void ReturnError(RpcErrorCode errCode, Exception ex)
{
var response = RpcResponseHeader.CreateError(errCode, ex);
ReturnError(response);
}
public void Return <T>(T results)
{
var response = RpcResponseHeader.CreateSuccess(results != null);
ReturnInner <T>(response, results);
}
public void Return()
{
var response = RpcResponseHeader.CreateSuccess(false);
ReturnInner <RpcNull>(response, null);
}
private void ProcessResponse(RpcResponseHeader response, long costTicks)
{
_response = response;
_observer.Track(response.ErrorCode == RpcErrorCode.OK, response.Error, costTicks);
_callback(this);
}
protected virtual void OnException(RpcRequestHeader requestHeader, RpcResponseHeader.Builder responseHeader,
Exception exception)
{
responseHeader.SetSuccess(false);
responseHeader.ClearContentLength();
responseHeader.SetException(RpcExceptionInfo.Create(exception, _exceptionDetails));
}
public virtual IMessageLite OnExecute(IClientContext client, RpcRequestHeader requestHeader,
CodedInputStream input, RpcResponseHeader.Builder responseHeader)
{
RpcCallContext previous = RpcCallContext.g_current;
try
{
responseHeader.SetMessageId(requestHeader.MessageId);
requestHeader.CallContext.Client = client;
RpcCallContext.g_current = requestHeader.CallContext;
IMessageLite responseBody = CallMethod(requestHeader, input);
if (RpcCallContext.g_current != null && !requestHeader.CallContext.Equals(RpcCallContext.g_current))
{
responseHeader.SetCallContext(RpcCallContext.g_current);
}
return responseBody;
}
catch (Exception ex)
{
OnException(requestHeader, responseHeader, ex);
return RpcVoid.DefaultInstance;
}
finally
{
RpcCallContext.g_current = previous;
}
}
