internal unsafe void _t_protocol_name_ResponseHandler(AsynReqRspArgs args)
{
byte *buffer = args.Buffer + args.Offset;
int size = args.Size - TrinityProtocol.AsyncWithRspAdditionalHeaderLength;
if (size < 0)
{
throw new ArgumentException("Async task completion handler encountered negative message size.");
}
// the token should be at the frontmost position
int token = *(int *)buffer;
int error = *(int *)(buffer + sizeof(int));
if (!s_t_protocol_name_token_sources.TryRemove(token, out var src))
{
throw new ArgumentException("Async task completion token not found while processing a AsyncWithResponse message.");
}
if (error != 0)
{
src.SetException(new Exception("AsyncWithResponse remote handler failed."));
return;
}
byte *buffer_clone = (byte *)Memory.malloc((ulong)(args.Size));
Memory.Copy(buffer, buffer_clone, args.Size);
var reader = new t_protocol_responseReader(buffer_clone, TrinityProtocol.AsyncWithRspAdditionalHeaderLength);
try { src.SetResult(reader); }
catch { Memory.free(buffer_clone); throw; }
}
/// <inheritdoc/>
public void SendMessage(byte **message, int *sizes, int count)
{
byte *buf;
int len;
_serialize(message, sizes, count, out buf, out len);
TrinityMessageType msgType = *(TrinityMessageType *)(buf + TrinityProtocol.MsgTypeOffset);
ushort msgId = *(ushort *)(buf + TrinityProtocol.MsgIdOffset);
// For async messages, we omit the buffer copy, use the serialized buffer directly.
switch (msgType)
{
case TrinityMessageType.ASYNC:
{
AsynReqArgs aut_request = new AsynReqArgs(
MessageHandlers.DefaultParser.async_handlers[msgId],
buf,
TrinityProtocol.MsgHeader,
len - TrinityProtocol.MsgHeader);
if (aut_request.AsyncProcessMessage() == TrinityErrorCode.E_RPC_EXCEPTION)
{
throw new IOException("Local message handler throws an exception.");
}
}
break;
case TrinityMessageType.ASYNC_WITH_RSP:
{
AsynReqRspArgs async_rsp_args = new AsynReqRspArgs(
MessageHandlers.DefaultParser.async_rsp_handlers[msgId],
buf,
TrinityProtocol.MsgHeader,
len - TrinityProtocol.MsgHeader);
if (async_rsp_args.AsyncProcessMessage() == TrinityErrorCode.E_RPC_EXCEPTION)
{
throw new IOException("Local message handler throws an exception.");
}
}
break;
default:
{
SendMessage(buf, len);
CMemory.C_free(buf);
}
break;
}
}
private unsafe void _StreamTriplesAsyncHandler(AsynReqRspArgs args)
{
using (var rsp = new ErrorCodeResponseWriter(asyncRspHeaderLength: TrinityProtocol.AsyncWithRspAdditionalHeaderLength))
{
Exception exception = null;
var req = new TripleStreamReader(args.Buffer, args.Offset + TrinityProtocol.AsyncWithRspAdditionalHeaderLength);
try { StreamTriplesAsyncHandler(req, rsp); }
catch (Exception ex) { exception = ex; }
int token = *(int *)(args.Buffer + args.Offset);
int from = *(int *)(args.Buffer + args.Offset + sizeof(int));
_StreamTriplesAsync_CheckError(exception, token, from);
*(int *)(rsp.buffer) = TrinityProtocol.TrinityMsgHeader + TrinityProtocol.AsyncWithRspAdditionalHeaderLength + rsp.Length;
*(TrinityMessageType *)(rsp.buffer + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.ASYNC_WITH_RSP;
*(ushort *)(rsp.buffer + TrinityProtocol.MsgIdOffset) = (ushort)global::Trinity.Client.TestProtocols.TSL.CommunicationModule.TripleServer.AsynReqRspMessageType.StreamTriplesAsync__Response;
*(int *)(rsp.m_ptr - TrinityProtocol.AsyncWithRspAdditionalHeaderLength) = token;
*(int *)(rsp.m_ptr - TrinityProtocol.AsyncWithRspAdditionalHeaderLength + sizeof(int)) = 0;
this.SendMessage(m_memorycloud[from], rsp.buffer, rsp.Length + TrinityProtocol.MsgHeader + TrinityProtocol.AsyncWithRspAdditionalHeaderLength);
}
}
/// <inheritdoc/>
public void SendMessage(byte *message, int size)
{
TrinityMessageType msgType = *(TrinityMessageType *)(message + TrinityProtocol.MsgTypeOffset);
ushort msgId = *(ushort *)(message + TrinityProtocol.MsgIdOffset);
TrinityErrorCode msgProcessResult;
switch (msgType)
{
case TrinityMessageType.PRESERVED_SYNC:
SynReqArgs preserved_sync_args = new SynReqArgs(message,
TrinityProtocol.MsgHeader, size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.preserved_sync_handlers[msgId]);
msgProcessResult = preserved_sync_args.MessageProcess();
break;
case TrinityMessageType.SYNC:
SynReqArgs sync_args = new SynReqArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.sync_handlers[msgId]);
msgProcessResult = sync_args.MessageProcess();
break;
case TrinityMessageType.PRESERVED_ASYNC:
{
AsynReqArgs aut_request = new AsynReqArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.preserved_async_handlers[msgId]);
msgProcessResult = aut_request.AsyncProcessMessage();
}
break;
case TrinityMessageType.ASYNC:
{
AsynReqArgs aut_request = new AsynReqArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.async_handlers[msgId]);
msgProcessResult = aut_request.AsyncProcessMessage();
}
break;
case TrinityMessageType.ASYNC_WITH_RSP:
{
AsynReqRspArgs async_rsp_args = new AsynReqRspArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.async_rsp_handlers[msgId]);
msgProcessResult = async_rsp_args.AsyncProcessMessage();
}
break;
default:
throw new IOException("Wrong message type.");
}
if (msgProcessResult == TrinityErrorCode.E_RPC_EXCEPTION)
{
throw new IOException("Local message handler throws an exception.");
}
}
internal void *DispatchMessage(MessageBuff *sendRecvBuff)
{
byte *ByteArray = sendRecvBuff->Buffer;
int Length = (int)sendRecvBuff->Length;
TrinityMessageType msgType = *(TrinityMessageType *)(sendRecvBuff->Buffer + TrinityProtocol.TrinityMsgTypeOffset);
ushort msgId = *(ushort *)(ByteArray + TrinityProtocol.TrinityMsgIdOffset);
TrinityErrorCode msgProcessResult;
try
{
switch (msgType)
{
case TrinityMessageType.SYNC_WITH_RSP:
SynReqRspArgs sync_rsp_args = new SynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
sync_rsp_handlers[msgId]);
msgProcessResult = sync_rsp_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff, sync_rsp_args.Response);
return(null);
case TrinityMessageType.PRESERVED_SYNC_WITH_RSP:
SynReqRspArgs preserved_sync_rsp_args = new SynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_sync_rsp_handlers[msgId]);
msgProcessResult = preserved_sync_rsp_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff, preserved_sync_rsp_args.Response);
return(null);
case TrinityMessageType.SYNC:
SynReqArgs sync_args = new SynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
sync_handlers[msgId]);
msgProcessResult = sync_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.PRESERVED_SYNC:
SynReqArgs preserved_sync_args = new SynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_sync_handlers[msgId]);
msgProcessResult = preserved_sync_args.MessageProcess();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.ASYNC:
AsynReqArgs async_args = new AsynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
async_handlers[msgId]);
msgProcessResult = async_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.PRESERVED_ASYNC:
AsynReqArgs preserved_async_args = new AsynReqArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
preserved_async_handlers[msgId]);
msgProcessResult = preserved_async_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
case TrinityMessageType.ASYNC_WITH_RSP:
AsynReqRspArgs async_rsp_args = new AsynReqRspArgs(ByteArray,
TrinityProtocol.TrinityMsgHeader,
Length - TrinityProtocol.TrinityMsgHeader,
async_rsp_handlers[msgId]);
msgProcessResult = async_rsp_args.AsyncProcessMessage();
_SetSendRecvBuff(msgProcessResult, sendRecvBuff);
return(null);
default:
throw new Exception("Not recognized message type.");
}
}
catch (MessageTooLongException ex)
{
Log.WriteLine("Message Type: " + msgType);
Log.WriteLine("Message SN: " + msgId);
Log.WriteLine(ex.Message);
Log.WriteLine(ex.StackTrace);
_SetSendRecvBuff(TrinityErrorCode.E_MSG_OVERFLOW, sendRecvBuff);
return(null);
}
catch (Exception ex)
{
Log.WriteLine("Message Type: " + msgType);
Log.WriteLine("Message SN: " + msgId);
Log.WriteLine(ex.Message);
Log.WriteLine(ex.StackTrace);
_SetSendRecvBuff(TrinityErrorCode.E_RPC_EXCEPTION, sendRecvBuff);
return(null);
}
}
