/// <inheritdoc />
public Task SendMessage(SampleMessage message)
{
var policyWrap = Policy.Handle <Exception>()
.FallbackAsync(cts => ProcessMessageForClient(SecondaryClient, message))
.WrapAsync(_circuitBreaker);
return(policyWrap.ExecuteAsync(() => ProcessMessageForClient(PrimaryClient, message)));
}
/// <summary>
/// Publishes <paramref name="message"/> to registered subscribers using <paramref name="client"/>.
/// </summary>
/// <returns></returns>
private async Task ProcessMessageForClient(ISenderClient client, SampleMessage message)
{
//Close the PrimaryClient object to see an exception that causes fail-over (PrimaryClient.CloseAsync().ConfigureAwait(false).GetAwaiter().GetResult(); in watch)
message.Sender = client == PrimaryClient ? "PrimaryClient" : "SecondaryClient";
string json = JsonConvert.SerializeObject(message);
var brokeredMessage = new Message(Encoding.UTF8.GetBytes(json));
brokeredMessage.UserProperties.Add("Type", message.GetType().Name);
await client.SendAsync(brokeredMessage).ConfigureAwait(false);
}
/// <summary>
/// Processes an incoming message.
/// </summary>
/// <param name="receiver"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task ProcessMessageForClient(IMessageReceiver receiver, Message message)
{
SampleMessage messageData = null;
try
{
messageData = DeserializeMessage(message);
}
catch (Exception ex)
{
//this is an issue, we received data that cannot be interpreted as MessageData.
await MessageProcessingFailed(message, ex).ConfigureAwait(false);
//move to dlc
if (message.SystemProperties.IsReceived)
{
await receiver.DeadLetterAsync(message.SystemProperties.LockToken, "Message cannot be deserialized into MessageData.").ConfigureAwait(false);
}
}
try
{
//if messageData is null, this means message is not supposed to be handled
if (messageData != null)
{
await ProcessMessage(receiver, message, messageData)
.ConfigureAwait(false);
}
else
{
//unable to process, and not interested
await receiver.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
}
}
catch (MessageLockLostException ex)
{
_logger?.LogWarning(ex, "Message lock was lost for message {MessageId}", message.MessageId);
}
catch (Exception ex)
{
await MessageProcessingFailed(message, ex).ConfigureAwait(false);
}
}
/// <summary>
/// Handles one message.
/// </summary>
/// <param name="receiver"></param>
/// <param name="serviceBusMessage"></param>
/// <param name="messageData"></param>
/// <returns></returns>
private async Task ProcessMessage(IMessageReceiver receiver, Message serviceBusMessage, SampleMessage messageData)
{
//TODO: de-duplicate messages
ImmutableList <SampleMessage> value;
if (_cache.TryGetValue("CacheKey", out var val))
{
value = (ImmutableList <SampleMessage>)val;
}
else
{
value = ImmutableList <SampleMessage> .Empty;
}
messageData.Receiver = receiver == _primaryMessageReceiver ? "PrimaryReceiver" : "SecondaryReceiver";
value = value.Add(messageData);
_cache.Set("CacheKey", value);
_logger.LogInformation("Received message with body: {MessageData}", messageData);
await receiver.CompleteAsync(serviceBusMessage.SystemProperties.LockToken).ConfigureAwait(false);
}
