/* * 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"); } }