private MessageReleaseAction OnMessageReceived(Message message) { // NOTE: type information does not belong here. It's a responsibility // of the serializer to be self-contained and put any information it // might need for rehydration. object payload; using (var stream = new MemoryStream(message.Body)) using (var reader = new StreamReader(stream)) { try { payload = this.serializer.Deserialize(reader); } catch (SerializationException e) { return(MessageReleaseAction.DeadLetterMessage(e.Message, e.ToString())); } } // TODO: have a better trace correlation mechanism (that is used in both the sender and receiver). string traceIdentifier = BuildTraceIdentifier(message); try { ProcessMessage(traceIdentifier, payload, message.MessageId, message.CorrelationId); } catch (Exception e) { return(HandleProcessingException(message, traceIdentifier, e)); } return(CompleteMessage(message, traceIdentifier)); }
private MessageReleaseAction HandleProcessingException(BrokeredMessage message, string traceIdentifier, Exception e) { if (message.DeliveryCount > MaxProcessingRetries) { Trace.TraceError("An error occurred while processing the message" + traceIdentifier + " and will be dead-lettered:\r\n{0}", e); return(MessageReleaseAction.DeadLetterMessage(e.Message, e.ToString())); } Trace.TraceWarning("An error occurred while processing the message" + traceIdentifier + " and will be abandoned:\r\n{0}", e); return(MessageReleaseAction.AbandonMessage); }
/// <summary> /// Called by the message receiver to start processing a message /// </summary> /// <param name="trans"></param> /// <param name="message"></param> private Task ProcessReceivedMessage(MessageQueueTransaction trans, Message message) { Envelope <Stream> envelope = MsmqMessageConverter.ConstructEnvelope(message); Task messageProcess = Task.Run(() => { MessageReleaseAction action = InvokeMessageHandler(envelope); CompleteMessage(message, trans, action); }); return(messageProcess); }
public Task ProcessRecieveMessage(Message message) { Envelope <Stream> envelope = AmazonSQSMessageConverter.ConstructEnvelope(message); Task messageProcess = Task.Run(() => { MessageReleaseAction releaseResult = InvokeMessageHandler(envelope); CompleteMessage(message, releaseResult); }); return(messageProcess); }
/// <summary> /// Called by the message receiver to start processing a message /// </summary> /// <param name="message"></param> private Task ProcessReceivedMessage(BrokeredMessage message) { Envelope <Stream> envelope = WindowsServiceBusMessageConverter.ConstructEnvelope(message); Task messageProcess = Task.Run(() => { MessageReleaseAction releaseResult = InvokeMessageHandler(envelope); CompleteMessage(message, releaseResult); }); return(messageProcess); }
private Task ProcessReceivedMessage(BasicGetResult result) { Envelope <Stream> envelope = RabbitMQMessageConverter.ConstructEnvelope(result); Task messageProcess = Task.Run(() => { MessageReleaseAction action = InvokeMessageHandler(envelope); CompleteMessage(result.DeliveryTag, action); }); return(messageProcess); }
private MessageReleaseAction HandleProcessingException(Message message, string traceIdentifier, Exception e) { if (message.SystemProperties.DeliveryCount > MaxProcessingRetries) { logger.LogError($"An error occurred while processing the message {traceIdentifier} and will be dead-lettered:\r\n{e.Message}"); return(MessageReleaseAction.DeadLetterMessage(e.Message, e.ToString())); } else { logger.LogWarning($"An error occurred while processing the message {traceIdentifier} and will be abandoned:\r\n{e.Message}"); return(MessageReleaseAction.AbandonMessage); } }
private void CompleteMessage(Message message, MessageQueueTransaction trans, MessageReleaseAction releaseResult) { switch (releaseResult) { case MessageReleaseAction.Abandon: case MessageReleaseAction.Complete: break; case MessageReleaseAction.DeadLetter: message.UseDeadLetterQueue = true; break; } trans.Commit(); trans.Dispose(); }
private void CompleteMessage(BrokeredMessage message, MessageReleaseAction action) { switch (action) { case MessageReleaseAction.Abandon: message.Abandon(); break; case MessageReleaseAction.Complete: message.Complete(); break; case MessageReleaseAction.DeadLetter: message.DeadLetter(); break; } }
/// <summary> /// Called by the message receiver to start processing a message /// </summary> /// <param name="message"></param> private Task ProcessReceivedMessage(BrokeredMessage message) { Envelope <Stream> envelope = WindowsServiceBusMessageConverter.ConstructEnvelope(message); Task messageProcess = Task.Run(() => { MessageReleaseAction releaseResult = InvokeMessageHandler(envelope); CompleteMessage(message, releaseResult); }); // http://stackoverflow.com/questions/30467896/brokeredmessage-automatically-disposed-after-calling-onmessage // "...The received message needs to be processed in the callback function's life time..." _cache.AddTask(messageProcess); return(messageProcess); }
private void CompleteMessage(Message message, MessageReleaseAction action) { DeleteMessageRequest request = new DeleteMessageRequest(QueueName, message.ReceiptHandle); _client.DeleteMessage(request); }
private void CompleteMessage(ulong DeliveryTag, MessageReleaseAction action) { _client.BasicAck(DeliveryTag, false); }