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); }