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);
}
public Ticket(ITicketOwner owner, call_body callBody, TReq reqArgs, TaskCreationOptions options, CancellationToken token)
{
_owner = owner;
_callBody = callBody;
_reqArgs = reqArgs;
_taskSrc = new TaskCompletionSource <TResp>(options);
if (token.CanBeCanceled)
{
_ctr = token.Register(Cancel);
}
else
{
_ctr = new CancellationTokenRegistration();
}
}
/// <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);
}
/// <summary>
/// creates the task for the control request to the RPC server
/// </summary>
public Task <TResp> CreateTask <TReq, TResp>(call_body callBody, TReq reqArgs, TaskCreationOptions options, CancellationToken token)
{
Ticket <TReq, TResp> ticket = new Ticket <TReq, TResp>(this, callBody, reqArgs, options, token);
lock (_sync)
{
if (token.IsCancellationRequested)
{
return(ticket.Task);
}
_pendingRequests.AddLast(ticket);
}
SendNextQueuedItem();
return(ticket.Task);
}
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);
}
/// <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);
}
public IRpcRequest <TResp> Request <TReq, TResp> (call_body callBody, TReq reqArgs)
{
throw new NotImplementedException();
}
public Task <TResp> CreateTask <TReq, TResp>(call_body callBody, TReq reqArgs, TaskCreationOptions options, CancellationToken token)
{
return(Task.Factory.StartNew <TResp>(() => Request <TReq, TResp>(callBody, reqArgs), token, options, TaskScheduler.Current));
}
