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; }
        }
Пример #2
0
        /// <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);
            }
        }
Пример #4
0
        /// <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.");
            }
        }
Пример #5
0
        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);
            }
        }