internal override void SendMessage(byte *message, int size, out TrinityResponse response)
{
TrinityResponse _rsp = null;
_use_synclient(sc => sc.SendMessage(message, size, out _rsp));
response = _rsp;
}
/// <returns>
/// E_SUCCESS: SendMessage success.
/// E_NETWORK_RECV_FAILURE: AckPackage cannot be received.
/// E_NETWORK_SEND_FAILURE: Failed to send message.
/// E_NOMEM: Failed to allocate memory for response message.
/// E_RPC_EXCEPTION: The remote handler throw an exception.
/// </returns>
public TrinityErrorCode SendMessage(byte *message, int size, out TrinityResponse response)
{
response = null;
if (DoSend(message, size))
{
byte * buf;
int len;
TrinityErrorCode recv_err = CNativeNetwork.ClientReceive(socket, out buf, out len);
if (recv_err == TrinityErrorCode.E_SUCCESS)
{
// will be freed by a message reader
response = new TrinityResponse(buf, len);
}
else if (recv_err == TrinityErrorCode.E_NETWORK_RECV_FAILURE)
{
// recv fail
sock_connected = false;
}
return(recv_err);
}
else
{
// send fail
sock_connected = false;
return(TrinityErrorCode.E_NETWORK_SEND_FAILURE);
}
}
/// <inheritdoc/>
public void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
TrinityResponse _rsp = null;
_use_synclient(sc => sc.SendMessage(message, sizes, count, out _rsp));
response = _rsp;
}
/// <inheritdoc/>
public void SendMessage(byte *message, int size, out TrinityResponse response)
{
TrinityMessageType msgType = *(TrinityMessageType *)(message + TrinityProtocol.MsgTypeOffset);
ushort msgId = *(ushort *)(message + TrinityProtocol.MsgIdOffset);
SynReqRspArgs sync_rsp_args;
TrinityErrorCode msgProcessResult;
if (msgType == TrinityMessageType.PRESERVED_SYNC_WITH_RSP)
{
sync_rsp_args = new SynReqRspArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.preserved_sync_rsp_handlers[msgId]);
}
else// msgType == TrinityMessageType.SYNC_WITH_RSP
{
sync_rsp_args = new SynReqRspArgs(message,
TrinityProtocol.MsgHeader,
size - TrinityProtocol.MsgHeader,
MessageHandlers.DefaultParser.sync_rsp_handlers[msgId]);
}
msgProcessResult = sync_rsp_args.MessageProcess();
if (msgProcessResult == TrinityErrorCode.E_SUCCESS)
{
response = new TrinityResponse(sync_rsp_args.Response);
}
else// msgProcessResult == TrinityErrorCode.E_RPC_EXCEPTION
{
throw new IOException("Local message handler throws an exception.");
}
}
public unsafe void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
int len = 0;
for (int i = 0; i < count; ++i)
{
len += sizes[i];
}
byte[] buf = new byte[len];
fixed(byte *p = buf)
{
byte *pp = p;
for (int i = 0; i < count; ++i)
{
Memory.memcpy(pp, message[i], (uint)sizes[i]);
pp += sizes[i];
}
}
var result = m_svcProxy.SendMessageWithResponseAsync(buf).Result;
byte *rsp = (byte *)Memory.malloc((uint)result.Length);
fixed(byte *p = result)
{
Memory.memcpy(rsp, p, (uint)result.Length);
}
response = new TrinityResponse(rsp, result.Length);
}
internal unsafe void PostResponse_impl(long p, byte *buf, int payload_len)
{
if (!m_rsp_tokens.TryRemove(p, out var tsrc))
{
throw new KeyNotFoundException();
}
int len = *(int *)buf;
if (len < 0)
{
tsrc.SetException(new IOException("The client remote handler throws an exception."));
}
else if (payload_len != len + TrinityProtocol.TrinityMsgHeader)
{
var ex = new IOException($"Client remote handler response size mismatch. Got {payload_len}, expecting {len + TrinityProtocol.TrinityMsgHeader}");
tsrc.SetException(ex);
throw ex;
}
else
{
byte *alloc_buf = (byte *)Memory.malloc((ulong)len);
Memory.memcpy(alloc_buf, buf + TrinityProtocol.SocketMsgHeader, (ulong)len);
TrinityResponse rsp = new TrinityResponse(alloc_buf, len);
tsrc.SetResult(rsp);
}
}
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response)
{
try
{
message += TrinityProtocol.SocketMsgHeader;
size -= TrinityProtocol.SocketMsgHeader;
byte[] buf = new byte[size];
fixed(byte *p = buf)
{
Memory.memcpy(p, message, (uint)size);
}
var result = m_svcProxy.SendMessageWithResponseAsync(buf).Result;
byte *rsp = (byte *)Memory.malloc((uint)result.Length);
fixed(byte *p = result)
{
Memory.memcpy(rsp, p, (uint)result.Length);
}
response = new TrinityResponse(rsp, result.Length);
}
catch (Exception ex)
{
Log.WriteLine(LogLevel.Error, "{0}", ex.ToString());
throw;
}
}
public unsafe void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
var msg_type = PointerHelper.GetUshort(message, sizes, TrinityProtocol.MsgTypeOffset);
ushort msg_id = PointerHelper.GetUshort(message, sizes, TrinityProtocol.MsgIdOffset);
int ms = ProtocolSemanticRegistry.s_protocolSemantics[msg_type, msg_id];
response = m_smrmfuncs[ms](message, sizes, count);
}
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response)
{
var msg_type = *(TrinityMessageType *)(message + TrinityProtocol.MsgTypeOffset);
ushort msg_id = *(ushort *)(message + TrinityProtocol.MsgIdOffset);
int ms = ProtocolSemanticRegistry.s_protocolSemantics[(int)msg_type, msg_id];
response = m_smrfuncs[ms](message, size);
}
protected unsafe void SendMessage(int moduleId, byte *buffer, int size, out TrinityResponse response)
{
byte b_msg_type = *(buffer + TrinityProtocol.MsgTypeOffset);
*(ushort *)(buffer + TrinityProtocol.MsgIdOffset) += m_MessageIdOffsets[b_msg_type];
m_sendMessageWithResponse(moduleId, buffer, size, out response);
}
/// <inheritdoc/>
public void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
byte *buf;
int len;
_serialize(message, sizes, count, out buf, out len);
SendMessage(buf, len, out response);
CMemory.C_free(buf);
}
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response)
{
void *p = Memory.malloc((ulong)size);
Memory.memcpy(p, message, (ulong)size);
var(treq, trsp) = QueueMessageWithRsp(p, size);
treq.Wait();
response = trsp.Result;
}
internal static bool GetCommunicationModuleOffset(this IMessagePassingEndpoint storage, string moduleName, out ushort synReqOffset, out ushort synReqRspOffset, out ushort asynReqOffset, out ushort asynReqRspOffset)
{
/******************
* Comm. protocol:
* - REQUEST : [char_cnt, char[] moduleName]
* - RESPONSE: [int synReqOffset, int synReqRspOffset, int asynReqOffset, int asynReqRspOffset]
* An response error code other than E_SUCCESS indicates failure of remote module lookup.
******************/
using (TrinityMessage tm = new TrinityMessage(
TrinityMessageType.PRESERVED_SYNC_WITH_RSP,
(ushort)RequestType.GetCommunicationModuleOffsets,
size: sizeof(int) + sizeof(char) * moduleName.Length))
{
PointerHelper sp = PointerHelper.New(tm.Buffer + TrinityMessage.Offset);
*sp.ip++ = moduleName.Length;
BitHelper.WriteString(moduleName, sp.bp);
TrinityResponse response = null;
bool ret;
try
{
storage.SendMessage(tm, out response);
ret = (response.ErrorCode == TrinityErrorCode.E_SUCCESS);
}
catch (System.IO.IOException)
{
ret = false;
}
if (ret)
{
sp.bp = response.Buffer + response.Offset;
int synReq_msg = *sp.ip++;
int synReqRsp_msg = *sp.ip++;
int asynReq_msg = *sp.ip++;
int asynReqRsp_msg = *sp.ip++;
synReqOffset = (ushort)synReq_msg;
synReqRspOffset = (ushort)synReqRsp_msg;
asynReqOffset = (ushort)asynReq_msg;
asynReqRspOffset = (ushort)asynReqRsp_msg;
}
else
{
synReqOffset = 0;
synReqRspOffset = 0;
asynReqOffset = 0;
asynReqRspOffset = 0;
}
response?.Dispose();
return(ret);
}
}
public unsafe void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response)
{
int size = Utils._sum(sizes, count);
void *p = Memory.malloc((ulong)size);
Utils._copy((byte *)p, message, sizes, count);
var(treq, trsp) = QueueMessageWithRsp(p, size);
treq.Wait();
response = trsp.Result;
}
internal override void SendMessage(byte *message, int size, out TrinityResponse response)
{
response = null;
TrinityErrorCode err = TrinityErrorCode.E_SUCCESS;
for (int i = 0; i < retry; i++)
{
SynClient sc = GetClient();
err = sc.SendMessage(message, size, out response);
PutBackClient(sc);
if (err == TrinityErrorCode.E_SUCCESS || err == TrinityErrorCode.E_RPC_EXCEPTION)
{
break;
}
}
_error_check(err);
}
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response)
{
byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)];
byte **bufs = stackalloc byte *[2];
int * sizes = stackalloc int[2];
bufs[0] = header;
bufs[1] = message;
sizes[0] = TrinityProtocol.MsgHeader + sizeof(int);
sizes[1] = size;
*(int *)header = TrinityProtocol.TrinityMsgHeader + sizeof(int) + size;
*(TrinityMessageType *)(header + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC_WITH_RSP;
*(ushort *)(header + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse;
*(int *)(header + TrinityProtocol.MsgHeader) = partitionId;
m_mod.SendMessage(m_ep, bufs, sizes, 2, out response);
}
public unsafe void SendMessage(byte **_bufs, int *_sizes, int count, out TrinityResponse response)
{
byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)];
ulong bufs_len = (ulong)(sizeof(byte *) * (count + 1));
ulong sizes_len = (ulong)(sizeof(int) * (count + 1));
byte **bufs = (byte **)Memory.malloc(bufs_len);
int * sizes = (int *)Memory.malloc(sizes_len);
bufs[0] = header;
sizes[0] = TrinityProtocol.MsgHeader + sizeof(int);
Memory.memcpy(bufs + 1, _bufs, bufs_len);
Memory.memcpy(sizes + 1, _sizes, sizes_len);
*(int *)header = TrinityProtocol.TrinityMsgHeader + sizeof(int) + Utils._sum(_sizes, count);
*(TrinityMessageType *)(header + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC_WITH_RSP;
*(ushort *)(header + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse;
*(int *)(header + TrinityProtocol.MsgHeader) = partitionId;
m_mod.SendMessage(m_ep, bufs, sizes, count + 1, out response);
}
public unsafe TrinityErrorCode LoadCell(long cellId, out byte[] cellBuff, out ushort cellType)
{
using (var req = new __CellIdStructWriter(cellId))
{
TrinityResponse rsp = null;
TrinityErrorCode errcode = TrinityErrorCode.E_RPC_EXCEPTION;
cellBuff = null;
cellType = 0;
try
{
var sp = PointerHelper.New(req.buffer);
*sp.ip++ = TrinityProtocol.TrinityMsgHeader + sizeof(long);
*sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP;
*sp.sp++ = (short)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.LoadCell;
m_mod.SendMessage(m_ep, req.buffer, req.BufferLength, out rsp);
sp = PointerHelper.New(rsp.Buffer);
errcode = (TrinityErrorCode)(*sp.ip++);
if (errcode == TrinityErrorCode.E_SUCCESS)
{
var length = *sp.ip++;
cellType = (ushort)(*sp.sp++);
cellBuff = new byte[length];
fixed(byte *p = cellBuff)
{
Memory.memcpy(p, sp.bp, (ulong)length);
}
}
/* otherwise, fails with returned error code */
}
finally
{
rsp?.Dispose();
}
return(errcode);
}
}
/// <inheritdoc/>
public void SendMessage(byte *message, int size, out TrinityResponse response)
{
MessageBuff buff = new MessageBuff();
buff.Buffer = message;
buff.Length = (uint)size;
LocalSendMessage(&buff);
int response_len = *(int *)buff.Buffer;
if (buff.Length != response_len + sizeof(int))
{
throw new IOException("Local message handler throws an exception.");
}
else
{
TrinityMessage rsp_message = new TrinityMessage(buff.Buffer, (int)buff.Length);
response = new TrinityResponse(rsp_message);
}
}
private unsafe TrinityErrorCode _SendCellPayload(long cellId, byte *buff, int size, ushort?cellType, short msgId)
{
//header: cellId, size, type
int header_len = TrinityProtocol.MsgHeader + sizeof(long) + sizeof(int) + (cellType.HasValue? sizeof(ushort): 0);
byte * header = stackalloc byte[header_len];
byte ** holder = stackalloc byte *[2];
int * length = stackalloc int[2];
PointerHelper sp = PointerHelper.New(header);
*sp.ip++ = header_len + size - TrinityProtocol.SocketMsgHeader;
*sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP;
*sp.sp++ = msgId;
*sp.lp++ = cellId;
*sp.ip++ = size;
if (cellType.HasValue)
{
*sp.sp++ = (short)cellType;
}
holder[0] = header;
holder[1] = buff;
length[0] = header_len;
length[1] = size;
TrinityResponse rsp = null;
try
{
m_mod.SendMessage(m_ep, holder, length, 2, out rsp);
return(*(TrinityErrorCode *)(rsp.Buffer));
}
finally
{
rsp?.Dispose();
}
}
/// <summary>
/// Send a binary message to the specified Trinity proxy.
/// </summary>
/// <param name="proxyId">A 32-bit proxy id.</param>
/// <param name="buffer">A binary message buffer.</param>
/// <param name="size">The size of the message.</param>
/// <param name="response">The TrinityResponse object returned by the Trinity proxy.</param>
public void SendMessageToProxy(int proxyId, byte *buffer, int size, out TrinityResponse response)
{
GetProxy(proxyId).SendMessage(buffer, size, out response);
}
public unsafe void SendMessage(byte **message, int *sizes, int count, out TrinityResponse response) => m_client.SendMessage(message, sizes, count, out response);
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response) => m_client.SendMessage(message, size, out response);
public static void SendMessage <T>(this IMessagePassingEndpoint storage, byte **message, int *sizes, int count, out TrinityResponse response)
where T : CommunicationModule
{
storage.GetCommunicationModule <T>().SendMessage(storage, message, sizes, count, out response);
}
public static void SendMessage(this IMessagePassingEndpoint storage, TrinityMessage message, out TrinityResponse response)
{
storage.SendMessage(message.Buffer, message.Size, out response);
}
protected internal unsafe new void SendMessage(IMessagePassingEndpoint ep, byte *buf, int size, out TrinityResponse rsp) => base.SendMessage(ep, buf, size, out rsp);
private static unsafe void t_send_message(byte *bufferPtr, int msgHeader, out TrinityResponse response)
{
throw new NotImplementedException();
}
/// <summary>
/// Send a binary message to the specified Trinity server.
/// </summary>
/// <param name="serverId">A 32-bit server id.</param>
/// <param name="buffer">A binary message buffer.</param>
/// <param name="size">The size of the message.</param>
/// <param name="response">The TrinityResponse object returned by the Trinity server.</param>
public void SendMessageToServer(int serverId, byte *buffer, int size, out TrinityResponse response)
{
StorageTable[serverId].SendMessage(buffer, size, out response);
}
internal void SendMessageToServer(int serverId, byte[] message, int offset, int size, out TrinityResponse response)
{
fixed(byte *p = message)
{
StorageTable[serverId].SendMessage(p + offset, size, out response);
}
}
internal void SendMessageToServer(int serverId, TrinityMessage msg, out TrinityResponse response)
{
StorageTable[serverId].SendMessage(msg, out response);
}
