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