/*
* public void Break()
* {
* _excepted(new RpcException("request error",
* new SocketException((int)SocketError.TimedOut)));
* }
*/
public void ReadResult(MessageReader mr, Reader r, rpc_msg respMsg)
{
Exception resEx = null;
TResult respArgs = default(TResult);
try
{
resEx = Toolkit.ReplyMessageValidate(respMsg);
if (resEx == null)
{
respArgs = r.Read <TResult>();
mr.CheckEmpty();
}
}
catch (Exception ex)
{
resEx = ex;
}
if (resEx == null)
{
Result(respArgs);
}
else
{
Except(resEx);
}
}
public TResp Request <TReq, TResp>(call_body callBody, TReq reqArgs)
{
UdpReader mr = new UdpReader(_receivedArray);
Reader r = Toolkit.CreateReader(mr);
rpc_msg respMsg = r.Read <rpc_msg>();
rpc_msg reqHeader = new rpc_msg()
{
xid = respMsg.xid, // use xid in _receivedArray
body = new body()
{
mtype = msg_type.CALL,
cbody = callBody
}
};
UdpWriter dtg = new UdpWriter();
Writer w = Toolkit.CreateWriter(dtg);
w.Write(reqHeader);
w.Write(reqArgs);
byte[] outBuff = dtg.Build();
Assert.AreEqual(_expectedSendArray, outBuff, "send dump is difference");
Toolkit.ReplyMessageValidate(respMsg);
TResp respArgs = r.Read <TResp>();
mr.CheckEmpty();
return(respArgs);
}
/// <summary>
/// asynchronous execution of an RPC request
/// </summary>
public IRpcRequest <TResp> Request <TReq, TResp>(call_body callBody, TReq reqArgs)
{
RpcRequest <TResp> handler = null;
try
{
handler = NewHandler <TResp>();
rpc_msg reqHeader = new rpc_msg()
{
xid = handler.Xid,
body = new body()
{
mtype = msg_type.CALL,
cbody = callBody
}
};
UdpDatagram dtg = new UdpDatagram();
Writer w = Toolkit.CreateWriter(dtg);
w.Write(reqHeader);
w.Write(reqArgs);
byte[] outBuff = dtg.ToArray();
//Log.Trace(() => "sending byte dump: " + outBuff.ToDisplay());
handler.OutBuff = outBuff;
EqueueSend(handler);
//lock (_sync)
// _sendingHandlers.Enqueue(handler);
//_client.BeginSend(outBuff, outBuff.Length, _ep, handler.DatagramSended, null);
}
catch (Exception ex)
{
if (handler == null)
{
handler = new RpcRequest <TResp>(null, 0);
}
ThreadPool.QueueUserWorkItem((o) => handler.Except(ex));
}
return(handler);
}
public void ReadResult(IMsgReader mr, Reader r, rpc_msg respMsg)
{
_ctr.Dispose();
try
{
Toolkit.ReplyMessageValidate(respMsg);
TResp respArgs = r.Read <TResp>();
mr.CheckEmpty();
_taskSrc.TrySetResult(respArgs);
}
catch (Exception ex)
{
_taskSrc.TrySetException(ex);
}
}
public void BuildRpcMessage(IByteWriter bw)
{
rpc_msg reqHeader = new rpc_msg()
{
xid = Xid,
body = new body()
{
mtype = msg_type.CALL,
cbody = _callBody
}
};
Writer xw = Toolkit.CreateWriter(bw);
xw.Write(reqHeader);
xw.Write(_reqArgs);
_callBody = null;
_reqArgs = default(TReq);
}
private void OnMessageReaded(Exception err, TcpReader tcpReader)
{
if (err != null)
{
Log.Debug("No receiving TCP messages. Reason: {0}", err);
OnException(err);
return;
}
lock (_sync)
_receivingInProgress = false;
rpc_msg respMsg = null;
Reader r = null;
try
{
r = Toolkit.CreateReader(tcpReader);
respMsg = r.Read <rpc_msg>();
}
catch (Exception ex)
{
Log.Info("Parse exception: {0}", ex);
BeginReceive();
return;
}
Log.Trace("Received response xid:{0}", respMsg.xid);
ITicket ticket = EnqueueTicket(respMsg.xid);
BeginReceive();
if (ticket == null)
{
Log.Debug("No handler for xid:{0}", respMsg.xid);
}
else
{
ticket.ReadResult(tcpReader, r, respMsg);
}
}
/// <summary>
/// synchronous execution of an RPC request
/// </summary>
/// <typeparam name="TReq"></typeparam>
/// <typeparam name="TResp"></typeparam>
/// <param name="callBody"></param>
/// <param name="reqArgs"></param>
/// <param name="completed"></param>
/// <param name="excepted"></param>
public IDisposable Request <TReq, TResp>(call_body callBody, TReq reqArgs, Action <TResp> completed, Action <Exception> excepted)
{
Exception resEx = null;
TResp respArgs = default(TResp);
rpc_msg reqHeader = new rpc_msg()
{
xid = 0xF1E2D3C4,
body = new body()
{
mtype = msg_type.CALL,
cbody = callBody
}
};
try
{
UdpDatagram dtg = new UdpDatagram();
Writer w = Toolkit.CreateWriter(dtg);
w.Write(reqHeader);
w.Write(reqArgs);
byte[] outBuff = dtg.ToArray();
Log.Trace(() => "sending byte dump: " + outBuff.ToDisplay());
_client.Send(outBuff, outBuff.Length, _ep);
MessageReader mr = new MessageReader();
Reader r = Toolkit.CreateReader(mr);
rpc_msg respMsg;
long endTime = Stopwatch.GetTimestamp() + _timeout * System.Diagnostics.Stopwatch.Frequency / 1000;
_client.Client.ReceiveTimeout = _timeout;
while (true)
{
IPEndPoint ep = _ep;
mr.Bytes = _client.Receive(ref ep);
respMsg = r.Read <rpc_msg>();
if (respMsg.xid == reqHeader.xid)
{
break;
}
int nextTimeout = (int)((double)((endTime - Stopwatch.GetTimestamp()) * 1000) / Stopwatch.Frequency);
if (nextTimeout <= 0)
{
throw new SocketException((int)SocketError.TimedOut);
}
else
{
_client.Client.ReceiveTimeout = nextTimeout;
}
}
Log.Trace(() => "received byte dump: " + mr.Bytes.ToDisplay());
resEx = Toolkit.ReplyMessageValidate(respMsg);
if (resEx == null)
{
respArgs = r.Read <TResp>();
mr.CheckEmpty();
}
}
catch (Exception ex)
{
resEx = new RpcException("request error", ex); //FIXME: may be to add more context of header
}
if (resEx == null)
{
completed(respArgs);
}
else
{
excepted(resEx);
}
return(null);
}
/// <summary>
/// returns the description of the RPC message
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
public static void ReplyMessageValidate(rpc_msg msg)
{
try
{
if (msg.body.mtype != msg_type.REPLY)
{
throw Exceptions.UnexpectedMessageType(msg.body.mtype);
}
reply_body replyBody = msg.body.rbody;
if (replyBody.stat == reply_stat.MSG_ACCEPTED)
{
accepted_reply.reply_data_union du = replyBody.areply.reply_data;
switch (du.stat)
{
case accept_stat.GARBAGE_ARGS:
throw Exceptions.GarbageArgs();
case accept_stat.PROC_UNAVAIL:
throw Exceptions.ProcedureUnavalible(replyBody);
case accept_stat.PROG_MISMATCH:
throw Exceptions.ProgramMismatch(replyBody, du.mismatch_info);
case accept_stat.PROG_UNAVAIL:
throw Exceptions.ProgramUnavalible(replyBody);
case accept_stat.SUCCESS:
return;
case accept_stat.SYSTEM_ERR:
throw Exceptions.SystemError(replyBody);
default:
throw Exceptions.NoRFC5531("msg");
}
}
if (replyBody.stat == reply_stat.MSG_DENIED)
{
if (replyBody.rreply.rstat == reject_stat.AUTH_ERROR)
{
throw Exceptions.AuthError(replyBody, replyBody.rreply.astat);
}
else if (replyBody.rreply.rstat == reject_stat.RPC_MISMATCH)
{
throw Exceptions.RpcVersionError(replyBody, replyBody.rreply.mismatch_info);
}
else
{
throw Exceptions.NoRFC5531("msg");
}
}
throw Exceptions.NoRFC5531("msg");
}
catch (NullReferenceException)
{
throw Exceptions.NoRFC5531("msg");
}
}
