Ejemplo n.º 1
0
        private void MessageHandler(object sender, MsgHandlerEventArgs e)
        {
            Core.Log.LibVerbose("Message received");

            try
            {
                (var body, var correlationId) = NATSQueueClient.GetFromMessageBody(e.Message.Data);
                var rMsg = new NATSQMessage
                {
                    CorrelationId = correlationId,
                    Body          = body
                };
                Task.Run(() => EnqueueMessageToProcessAsync(ProcessingTaskAsync, rMsg));
            }
            catch (Exception ex)
            {
                Core.Log.Write(ex);
            }
        }
Ejemplo n.º 2
0
        private async Task ProcessingTaskAsync(NATSQMessage message)
        {
            try
            {
                Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", message.Body.Count, Connection.Route, Connection.Name);
                var messageBody = ReceiverSerializer.Deserialize(message.Body, _messageType);
                switch (messageBody)
                {
                case RequestMessage request when request.Header != null:
                    request.Header.ApplicationReceivedTime = Core.Now;
                    Counters.IncrementReceivingTime(request.Header.TotalTime);
                    if (request.Header.ClientName != Config.Name)
                    {
                        Core.Log.Warning("The Message Client Name '{0}' is different from the Server Name '{1}'", request.Header.ClientName, Config.Name);
                    }
                    var evArgs = new RequestReceivedEventArgs(_name, Connection, request, message.Body.Count);
                    if (request.Header.ResponseQueue != null)
                    {
                        evArgs.ResponseQueues.Add(request.Header.ResponseQueue);
                    }
                    await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);

                    break;

                case ResponseMessage response when response.Header != null:
                    response.Header.Response.ApplicationReceivedTime = Core.Now;
                    Counters.IncrementReceivingTime(response.Header.Response.TotalTime);
                    var evArgs2 = new ResponseReceivedEventArgs(_name, response, message.Body.Count);
                    await OnResponseReceivedAsync(evArgs2).ConfigureAwait(false);

                    break;
                }
                Counters.IncrementTotalMessagesProccesed();
            }
            catch (Exception ex)
            {
                Counters.IncrementTotalExceptions();
                Core.Log.Write(ex);
                lock (_lock)
                    _exceptionSleep = true;
            }
        }
        private async Task ProcessingTaskAsync(NATSQMessage message)
        {
            try
            {
                Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", message.Body.Count, Connection.Route, Connection.Name);
                Counters.IncrementTotalReceivingBytes(message.Body.Count);

                if (ResponseServer)
                {
                    var evArgs =
                        new RawResponseReceivedEventArgs(_name, message.Body, message.CorrelationId, message.Body.Count)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = message.Name
                        }
                    };
                    await OnResponseReceivedAsync(evArgs).ConfigureAwait(false);
                }
                else
                {
                    var evArgs =
                        new RawRequestReceivedEventArgs(_name, Connection, message.Body, message.CorrelationId, message.Body.Count)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = message.Name
                        }
                    };
                    await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
                }
                Counters.IncrementTotalMessagesProccesed();
            }
            catch (Exception ex)
            {
                Counters.IncrementTotalExceptions();
                Core.Log.Write(ex);
                lock (_lock)
                    _exceptionSleep = true;
            }
        }