Exemplo n.º 1
0
        private async Task ProcessingTaskAsync(RedisValue data)
        {
            try
            {
                (var body, var correlationId, var name) = RedisQueueRawClient.GetFromRawMessageBody(data);

                Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", body.Count, Connection.Route, Connection.Name);
                Counters.IncrementTotalReceivingBytes(body.Count);

                if (ResponseServer)
                {
                    var evArgs =
                        new RawResponseReceivedEventArgs(_name, body, correlationId, body.Count)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = name
                        }
                    };
                    await OnResponseReceivedAsync(evArgs).ConfigureAwait(false);
                }
                else
                {
                    var evArgs =
                        new RawRequestReceivedEventArgs(_name, Connection, body, correlationId, body.Count)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = name
                        }
                    };
                    await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
                }
                Counters.IncrementTotalMessagesProccesed();
            }
            catch (Exception ex)
            {
                Counters.IncrementTotalExceptions();
                Core.Log.Write(ex);
                Interlocked.Exchange(ref _exceptionSleep, 1);
            }
        }
Exemplo n.º 2
0
        private async Task ProcessingTaskAsync(Message message)
        {
            try
            {
                var(correlationId, name) = KafkaQueueRawClient.GetFromRawMessageHeader(message.Key);
                var body = message.Value;

                Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", body.Length, Connection.Route, Connection.Name);
                Counters.IncrementTotalReceivingBytes(body.Length);

                if (ResponseServer)
                {
                    var evArgs =
                        new RawResponseReceivedEventArgs(_name, body, correlationId, body.Length)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = name
                        }
                    };
                    await OnResponseReceivedAsync(evArgs).ConfigureAwait(false);
                }
                else
                {
                    var evArgs =
                        new RawRequestReceivedEventArgs(_name, Connection, body, correlationId, body.Length)
                    {
                        Metadata =
                        {
                            ["ReplyTo"] = name
                        }
                    };
                    await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
                }
                Counters.IncrementTotalMessagesProccesed();
            }
            catch (Exception ex)
            {
                Counters.IncrementTotalExceptions();
                Core.Log.Write(ex);
            }
        }
        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;
            }
        }
 private async Task ProcessingTaskAsync(RabbitMessage message)
 {
     if (message.Body == null)
     {
         return;
     }
     try
     {
         Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", message.Body.Length, _receiver.Route, _receiver.Name);
         Counters.IncrementTotalReceivingBytes(message.Body.Length);
         if (ResponseServer)
         {
             var evArgs =
                 new RawResponseReceivedEventArgs(_name, message.Body, message.CorrelationId, message.Body.Length)
             {
                 Metadata =
                 {
                     ["AppId"]           = message.Properties.AppId,
                     ["ContentEncoding"] = message.Properties.ContentEncoding,
                     ["ContentType"]     = message.Properties.ContentType,
                     ["DeliveryMode"]    = message.Properties.DeliveryMode.ToString(),
                     ["Expiration"]      = message.Properties.Expiration,
                     ["Priority"]        = message.Properties.Priority.ToString(),
                     ["Timestamp"]       = message.Properties.Timestamp.ToString(),
                     ["Type"]            = message.Properties.Type,
                     ["UserId"]          = message.Properties.UserId,
                     ["ReplyTo"]         = message.Properties.ReplyTo,
                     ["MessageId"]       = message.Properties.MessageId
                 }
             };
             await OnResponseReceivedAsync(evArgs).ConfigureAwait(false);
         }
         else
         {
             var evArgs =
                 new RawRequestReceivedEventArgs(_name, _receiver, message.Body, message.CorrelationId, message.Body.Length)
             {
                 Metadata =
                 {
                     ["AppId"]           = message.Properties.AppId,
                     ["ContentEncoding"] = message.Properties.ContentEncoding,
                     ["ContentType"]     = message.Properties.ContentType,
                     ["DeliveryMode"]    = message.Properties.DeliveryMode.ToString(),
                     ["Expiration"]      = message.Properties.Expiration,
                     ["Priority"]        = message.Properties.Priority.ToString(),
                     ["Timestamp"]       = message.Properties.Timestamp.ToString(),
                     ["Type"]            = message.Properties.Type,
                     ["UserId"]          = message.Properties.UserId,
                     ["ReplyTo"]         = message.Properties.ReplyTo,
                     ["MessageId"]       = message.Properties.MessageId
                 }
             };
             await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
         }
         Counters.IncrementTotalMessagesProccesed();
     }
     catch (Exception ex)
     {
         Counters.IncrementTotalExceptions();
         Core.Log.Write(ex);
         lock (_lock)
             _exceptionSleep = true;
     }
 }