public int TestException(string serverUrl, string param, RpcErrorCode exceptedCode, string errMsg)
{
Stopwatch watch = new Stopwatch();
watch.Start();
try
{
RpcClientProxy proxy = RpcProxyFactory.GetProxy <IRpcTestService>(serverUrl);
proxy.Invoke <string, string>("TestException", param);
Assert.Fail("Should Failed...");
}
catch (RpcException ex)
{
Console.WriteLine(ex.ToString());
Assert.AreEqual(exceptedCode, ex.RpcCode);
if (!string.IsNullOrEmpty(errMsg))
{
Assert.IsTrue(ex.ToString().Contains(errMsg));
}
}
int ms = (int)watch.ElapsedMilliseconds;
Console.WriteLine("Cost Ms: {0}", ms);
return(ms);
}
public RpcException(RpcErrorCode code, string serviceUrl, string message, Exception ex)
: base(string.Format("RpcException<{0}> on {1} '{2}'", code, serviceUrl, message), ex)
{
_code = code;
_serviceUrl = serviceUrl;
_message = message;
}
public RpcException(string message, string url, BaseUri uri, RpcErrorCode code, Exception ex)
: base(null, ex)
{
_message = message;
_serviceUrl = url;
_toUri = ObjectHelper.ToString(uri);
_code = code;
}
private void ProcessFailedTxs(RpcBatchClientTransaction[] trans, RpcErrorCode code, Exception ex)
{
foreach (var tx in trans)
{
tx.Response = RpcResponse.Create(code, ex);
tx.OnTransactionEnd();
}
}
public void SetResults(int i, RpcErrorCode code, Exception ex)
{
_responses[i] = new RpcBatchResponse()
{
ErrorCode = code,
ResponseData = ex != null?Encoding.UTF8.GetBytes(ex.ToString()) : null
};
}
public RpcException(string message, string url, BaseUri uri, RpcErrorCode code, Exception ex)
: base(null, ex)
{
_message = message;
_serviceUrl = url;
_toUri = ObjectHelper.ToString(uri);
_code = code;
}
/// <param name="code">Rpc error code</param>
/// <param name="message">Error message</param>
/// <param name="data">Optional error data</param>
public RpcError(RpcErrorCode code, string message, object data = null)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentNullException(nameof(message));
}
this.Code = code;
this.Message = message;
this.Data = data;
}
private void ProcessSendFailed(IEnumerable <IRpcTcpSendingPacket> packets, RpcErrorCode code, Exception ex)
{
foreach (var p in packets)
{
_counter.SendFailed.Increment();
try {
p.SendFailed(RpcErrorCode.SendFailed, ex);
} catch (Exception e) {
_tracing.Error(e, "ProcessSendFailed error");
}
}
}
public static RpcResponse Create(RpcErrorCode code, Exception ex)
{
if (ex != null)
{
var body = new RpcBodyBuffer(ex);
return(new RpcResponse(code, body));
}
else
{
return(new RpcResponse(code, null));
}
}
private static void ResponseCallback(IAsyncResult asyncResult)
{
RpcHttpClientTransaction trans = (RpcHttpClientTransaction)asyncResult.AsyncState;
RpcResponseHeader header = null;
try {
var response = trans._webRequest.EndGetResponse(asyncResult);
trans._webResponse = response;
string warn = response.Headers.Get("Warning");
if (!string.IsNullOrEmpty(warn))
{
RpcErrorCode errCode = (RpcErrorCode)Enum.Parse(typeof(RpcErrorCode), warn);
if (errCode != RpcErrorCode.OK)
{
Exception ex = null;
if (response.ContentLength > 0)
{
Stream stream = response.GetResponseStream();
ex = BinarySerializer.Deserialize <Exception>(stream);
}
header = RpcResponseHeader.CreateError(errCode, ex);
}
else
{
SystemLog.Error(LogEventID.RpcFailed, "Unexcepted Message");
header = RpcResponseHeader.CreateError(RpcErrorCode.Unknown, null);
}
}
else
{
bool hasBody = (response.Headers["Null"] != "true");
header = RpcResponseHeader.CreateSuccess(hasBody);
}
} catch (WebException ex) {
if (ex.Status == WebExceptionStatus.Timeout)
{
header = RpcResponseHeader.CreateError(RpcErrorCode.TransactionTimeout, ex);
}
else
{
header = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
}
} catch (Exception ex) {
header = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
}
trans._callback(header);
trans._waitHandle.Set();
}
public void ReturnError(RpcErrorCode errCode, Exception ex)
{
var response = RpcResponseHeader.CreateError(errCode, ex);
ReturnError(response);
}
public void SendFailed(RpcErrorCode code, Exception ex)
{
Response = RpcResponse.Create(code, ex);
RpcTcpTransactionManager.EndTransaction(Sequence, Response);
}
public void SetResults(RpcErrorCode code, Exception ex)
{
_ctx.SetResults(_idx, code, ex);
}
public bool HasBody; // Body is null
private RpcResponseHeader(bool hasBody)
{
ErrorCode = RpcErrorCode.OK;
Error = null;
HasBody = hasBody;
}
/// <param name="errorCode">Rpc error code</param>
/// <param name="message">Error message</param>
/// <param name="data">Custom data if needed for error response</param>
/// <param name="innerException">Inner exception (optional)</param>
protected RpcException(RpcErrorCode errorCode, string message, object data = null, Exception innerException = null) : base(message, innerException)
{
this.ErrorCode = errorCode;
this.RpcData = data;
}
public static RpcResponse Create(RpcErrorCode code, Stream stream, int streamLen)
{
return(new RpcResponse(code, new RpcBodyBuffer(stream, streamLen)));
}
public static RpcResponseHeader CreateError(RpcErrorCode code, Exception ex)
{
return new RpcResponseHeader(code, ex);
}
/// <summary>
/// 返回错误到客户端
/// </summary>
/// <param name="errCode">错误码</param>
/// <param name="ex">异常</param>
public void ReturnError(RpcErrorCode errCode, Exception ex)
{
RpcResponse response = RpcResponse.Create(errCode, ex);
SendResponse(response);
}
public RpcResponse(RpcErrorCode code, RpcBodyBuffer body)
{
ErrorCode = code;
BodyBuffer = body;
}
public HttpRpcClientBuilder DeserializeErrorDataAs <T>(RpcErrorCode errorCode)
{
return(this.DeserializeErrorDataAs <T>((int)errorCode));
}
/// <param name="errorCode">Rpc error code</param>
/// <param name="message">Error message</param>
/// <param name="data">Custom data if needed for error response</param>
/// <param name="innerException">Inner exception (optional)</param>
public RpcException(RpcErrorCode errorCode, string message, Exception?innerException = null, object?data = null)
: this((int)errorCode, message, innerException, data)
{
}
public RpcException(string message, string url, RpcErrorCode code, Exception ex)
: this(message, url, null, code, ex)
{
}
public static RpcResponseHeader CreateError(RpcErrorCode code, Exception ex)
{
return(new RpcResponseHeader(code, ex));
}
private RpcResponseHeader(RpcErrorCode code, Exception ex)
{
ErrorCode = code;
Error = ex;
HasBody = (ex != null);
}
public bool HasBody; // Body is null
#endregion Fields
#region Constructors
private RpcResponseHeader(bool hasBody)
{
ErrorCode = RpcErrorCode.OK;
Error = null;
HasBody = hasBody;
}
private RpcResponseHeader(RpcErrorCode code, Exception ex)
{
ErrorCode = code;
Error = ex;
HasBody = (ex != null);
}
public RpcError(RpcErrorCode code, string message, T data)
: base(code, message, data)
{
}
public void ReturnError(RpcErrorCode errCode, Exception ex)
{
_innerCtx.ReturnError(errCode, ex);
}
private async Task SendErrorOutput(HttpResponse response, RpcErrorCode code)
{
response.ContentType = "application/json";
await response.WriteAsync(JsonConvert.SerializeObject(FunctionOutput.WithError(code)));
}
public static RpcResponse Create(RpcErrorCode code)
{
return(new RpcResponse(code, null));
}
public RpcException(string message, string url, RpcErrorCode code, Exception ex)
: this(message, url, null, code, ex)
{
}
/// <param name="code">Rpc error code</param>
/// <param name="message">Error message</param>
/// <param name="data">Optional error data</param>
public RpcError(RpcErrorCode code, string message, JToken data = null) : this((int)code, message, data)
{
}
public void SendFailed(RpcErrorCode code, Exception ex)
{
// do Nothing
_tracing.ErrorFmt(ex, "TcpServerTransaction SendFailed {0} - {1}", code, ex);
}