private bool CallMessageHandlers(Message message)
{
var handlerFuncs = _handlerMap.Get(message.GetType());
if (handlerFuncs == null)
{
return true;
}
var allHandlersSucceeded = true;
foreach (var handlerFunc in handlerFuncs)
{
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
var thisHandlerSucceeded = handlerFunc(message);
allHandlersSucceeded = allHandlersSucceeded && thisHandlerSucceeded;
watch.Stop();
Log.Trace("Handled message - MessageType: {0}", message.GetType().Name);
_messagingMonitor.HandleTime(watch.ElapsedMilliseconds);
}
return allHandlersSucceeded;
}
public void Publish(Message message)
{
_client.SendMessage(new SendMessageRequest
{
MessageBody = GetMessageInContext(message),
QueueUrl = Url
});
}
private async Task <bool> CallMessageHandler(string queueName, Message message, CancellationToken cancellationToken)
{
var messageType = message.GetType();
var middleware = _middlewareMap.Get(queueName, messageType);
if (middleware == null)
{
_logger.LogError(
"Failed to dispatch. Middleware for message of type '{MessageTypeName}' not found in middleware map.",
message.GetType().FullName);
return(false);
}
var watch = System.Diagnostics.Stopwatch.StartNew();
using (_messagingMonitor.MeasureDispatch())
{
bool dispatchSuccessful = false;
try
{
var context = new HandleMessageContext(message, messageType, queueName);
dispatchSuccessful = await middleware.RunAsync(context, null, cancellationToken)
.ConfigureAwait(false);
}
finally
{
watch.Stop();
var logMessage =
"{Status} handling message with Id '{MessageId}' of type {MessageType} in {TimeToHandle}ms.";
if (dispatchSuccessful)
{
_logger.LogInformation(logMessage,
"Succeeded",
message.Id,
messageType,
watch.ElapsedMilliseconds);
}
else
{
_logger.LogWarning(logMessage,
"Failed",
message.Id,
messageType,
watch.ElapsedMilliseconds);
}
}
return(dispatchSuccessful);
}
}
private PublishRequest BuildPublishRequest(Message message, PublishMetadata metadata)
{
var messageToSend = _serializationRegister.Serialize(message, serializeForSnsPublishing: true);
var messageType = _messageSubjectProvider.GetSubjectForType(message.GetType());
return(new PublishRequest
{
TopicArn = Arn,
Subject = messageType,
Message = messageToSend,
MessageAttributes = BuildMessageAttributes(metadata)
});
}
private protected override Task <SqsMessagePublisher> CreateSystemUnderTestAsync()
{
var sqs = new SqsMessagePublisher(new Uri(Url), Sqs, _serializationRegister, Substitute.For <ILoggerFactory>())
{
MessageResponseLogger = (r, m) =>
{
_response = r;
_message = m;
}
};
return(Task.FromResult(sqs));
}
private SendMessageRequest BuildSendMessageRequest(Message message)
{
var request = new SendMessageRequest
{
MessageBody = GetMessageInContext(message),
QueueUrl = Uri?.AbsoluteUri
};
if (message.DelaySeconds.HasValue)
{
request.DelaySeconds = message.DelaySeconds.Value;
}
return(request);
}
private SendMessageRequest BuildSendMessageRequest(Message message, PublishMetadata metadata)
{
var request = new SendMessageRequest
{
MessageBody = GetMessageInContext(message),
QueueUrl = Uri?.AbsoluteUri,
};
if (metadata?.Delay != null)
{
request.DelaySeconds = (int)metadata.Delay.Value.TotalSeconds;
}
return(request);
}
public void Publish(Message message)
{
var messageToSend = _serialisationRegister.Serialise(message, serializeForSnsPublishing:true);
var messageType = message.GetType().Name;
Client.Publish(new PublishRequest
{
Subject = messageType,
Message = messageToSend,
TopicArn = Arn
});
EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend);
}
protected override SqsPublisher CreateSystemUnderTest()
{
var sqs = new SqsPublisher(RegionEndpoint.EUWest1, QueueName, _sqs, 0, _serialisationRegister, Substitute.For <ILoggerFactory>())
{
MessageResponseLogger = (r, m) =>
{
_response = r;
_message = m;
}
};
sqs.ExistsAsync().GetAwaiter().GetResult();
return(sqs);
}
protected virtual void Given()
{
_typedMessage = new OrderAccepted();
_sqsMessage = new SQSMessage
{
Body = JsonConvert.SerializeObject(_typedMessage),
ReceiptHandle = "i_am_receipt_handle"
};
_loggerFactory.CreateLogger(Arg.Any <string>()).Returns(_logger);
_queue = new DummySqsQueue(new Uri(ExpectedQueueUrl), _amazonSqsClient);
_serializationRegister.DeserializeMessage(Arg.Any <string>()).Returns(_typedMessage);
}
public void Publish(Message message)
{
var messageToSend = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message);
var messageType = message.GetType().Name;
Client.Publish(new PublishRequest
{
Subject = messageType,
Message = messageToSend,
TopicArn = Arn
});
EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend);
}
public void Publish(Message message)
{
var messageToSend = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message);
var messageType = message.GetType().ToKey();
Client.Publish(new PublishRequest
{
Subject = messageType,
Message = messageToSend,
TopicArn = Arn
});
EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend);
}
private protected override async Task <SqsPublisher> CreateSystemUnderTestAsync()
{
var sqs = new SqsPublisher(RegionEndpoint.EUWest1, QueueName, Sqs, 0, _serializationRegister, Substitute.For <ILoggerFactory>())
{
MessageResponseLogger = (r, m) =>
{
_response = r;
_message = m;
}
};
await sqs.ExistsAsync();
return(sqs);
}
private async Task <bool> CallMessageHandler(string queueName, Message message)
{
var messageType = message.GetType();
var handler = _handlerMap.Get(queueName, messageType);
if (handler == null)
{
_logger.LogError(
"Failed to dispatch. Handler for message of type '{MessageTypeName}' not found in handler map.",
message.GetType().FullName);
return(false);
}
var watch = System.Diagnostics.Stopwatch.StartNew();
using (_messagingMonitor.MeasureHandler())
{
bool handlerSucceeded = false;
try
{
handlerSucceeded = await handler(message).ConfigureAwait(false);
}
finally
{
watch.Stop();
var logMessage =
"{Status} handling message with Id '{MessageId}' of type {MessageType} in {TimeToHandle}ms.";
if (handlerSucceeded)
{
_logger.LogInformation(logMessage,
"Succeeded",
message.Id,
messageType,
watch.ElapsedMilliseconds);
}
else
{
_logger.LogWarning(logMessage,
"Failed",
message.Id,
messageType,
watch.ElapsedMilliseconds);
}
}
return(handlerSucceeded);
}
}
public async Task PublishAsync(Message message)
{
var request = BuildSendMessageRequest(message);
try
{
await _client.SendMessageAsync(request).ConfigureAwait(false);
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}",
ex);
}
}
public void Publish(Message message)
{
var request = BuildSendMessageRequest(message);
try
{
_client.SendMessage(request);
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}",
ex);
}
}
public void Publish(Message message)
{
var request = BuildPublishRequest(message);
try
{
Client.Publish(request);
_eventLog.LogInformation($"Published message: '{request.Subject}' with content {request.Message}");
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}",
ex);
}
}
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken)
{
if (QueueUrl is null)
{
throw new PublishException("Queue URL was null, perhaps you need to call `StartAsync` on the `IMessagePublisher` before publishing.");
}
var request = BuildSendMessageRequest(message, metadata);
SendMessageResponse response;
try
{
response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false);
}
catch (AmazonServiceException ex)
{
throw new PublishException(
$"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}",
ex);
}
using (_logger.BeginScope(new Dictionary <string, object>
{
["AwsRequestId"] = response?.MessageId
}))
{
_logger.LogInformation(
"Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.",
message.Id,
message.GetType().FullName,
"Queue",
request.QueueUrl);
}
if (MessageResponseLogger != null)
{
var responseData = new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId,
ResponseMetadata = response?.ResponseMetadata
};
MessageResponseLogger.Invoke(responseData, message);
}
}
private async Task <bool> CallMessageHandler(Message message)
{
var handler = _handlerMap.Get(message.GetType());
if (handler == null)
{
return(true);
}
var watch = System.Diagnostics.Stopwatch.StartNew();
var handlerSucceeded = await handler(message).ConfigureAwait(false);
watch.Stop();
_log.LogTrace($"Handled message - MessageType: {message.GetType().Name}");
_messagingMonitor.HandleTime(watch.ElapsedMilliseconds);
return(handlerSucceeded);
}
public async Task PublishAsync(Message message)
{
var request = new SendMessageRequest
{
MessageBody = GetMessageInContext(message),
QueueUrl = Url
};
try
{
await _client.SendMessageAsync(request);
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}",
ex);
}
}
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken)
{
var request = BuildPublishRequest(message, metadata);
PublishResponse response = null;
try
{
response = await Client.PublishAsync(request, cancellationToken).ConfigureAwait(false);
}
catch (AmazonServiceException ex)
{
if (!ClientExceptionHandler(ex, message))
{
throw new PublishException(
$"Failed to publish message to SNS. Topic ARN: '{request.TopicArn}', Subject: '{request.Subject}', Message: '{request.Message}'.",
ex);
}
}
using (_logger.BeginScope(new[]
{
new KeyValuePair <string, object>("AwsRequestId", response?.MessageId)
}))
{
_logger.LogInformation(
"Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.",
message.Id,
message.GetType().Name,
"Topic",
request.TopicArn);
}
if (MessageResponseLogger != null)
{
var responseData = new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId,
ResponseMetadata = response?.ResponseMetadata
};
MessageResponseLogger.Invoke(responseData, message);
}
}
public async Task PublishAsync(Message message)
{
var request = BuildPublishRequest(message);
try
{
await Client.PublishAsync(request).ConfigureAwait(false);
_eventLog.LogInformation($"Published message: '{request.Subject}' with content {request.Message}");
}
catch (Exception ex)
{
if (!ClientExceptionHandler(ex))
{
throw new PublishException(
$"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}",
ex);
}
}
}
private async Task <bool> CallMessageHandler(Message message)
{
var handler = _handlerMap.Get(message.GetType());
if (handler == null)
{
return(true);
}
var watch = System.Diagnostics.Stopwatch.StartNew();
var handlerSucceeded = await handler(message).ConfigureAwait(false);
watch.Stop();
_logger.LogTrace("Handled message of type {MessageType} in {TimeToHandle}.",
message.GetType(), watch.Elapsed);
_messagingMonitor.HandleTime(watch.Elapsed);
return(handlerSucceeded);
}
public void Publish(Message message)
{
var request = BuildSendMessageRequest(message);
try
{
var response = _client.SendMessage(request);
MessageResponseLogger?.Invoke(new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId
}, message);
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}",
ex);
}
}
public async Task PublishAsync(Message message, CancellationToken cancellationToken)
{
var request = BuildSendMessageRequest(message);
try
{
var response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false);
MessageResponseLogger?.Invoke(new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId
}, message);
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}",
ex);
}
}
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken)
{
var request = BuildSendMessageRequest(message, metadata);
SendMessageResponse response;
try
{
response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false);
}
catch (AmazonServiceException ex)
{
throw new PublishException(
$"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}",
ex);
}
using (Logger.BeginScope(new[]
{
new KeyValuePair <string, object>("AwsRequestId", response?.MessageId)
}))
{
Logger.LogInformation(
"Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.",
message.Id,
message.GetType().Name,
"Queue",
request.QueueUrl);
}
if (MessageResponseLogger != null)
{
var responseData = new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId,
ResponseMetadata = response?.ResponseMetadata
};
MessageResponseLogger.Invoke(responseData, message);
}
}
protected virtual void Given()
{
_typedMessage = new OrderAccepted();
_sqsMessage = new SQSMessage
{
Body = JsonConvert.SerializeObject(_typedMessage),
ReceiptHandle = "i_am_receipt_handle"
};
IEnumerable <SQSMessage> GetMessages()
{
yield return(_sqsMessage);
}
_queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages()))
{
Uri = new Uri(ExpectedQueueUrl)
};
_serializationRegister.DeserializeMessage(Arg.Any <string>())
.Returns(new MessageWithAttributes(_typedMessage, new MessageAttributes()));
}
public async Task PublishAsync(Message message)
{
var messageToSend = _serialisationRegister.Serialise(message, serializeForSnsPublishing: true);
var messageType = message.GetType().Name;
var request = new PublishRequest
{
TopicArn = Arn,
Subject = messageType,
Message = messageToSend
};
try
{
await Client.PublishAsync(request);
_eventLog.LogInformation($"Published message: '{messageType}' with content {messageToSend}");
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}",
ex);
}
}
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken)
{
var request = BuildPublishRequest(message, metadata);
PublishResponse response = null;
try
{
response = await Client.PublishAsync(request, cancellationToken).ConfigureAwait(false);
}
catch (AmazonServiceException ex)
{
if (!ClientExceptionHandler(ex, message))
{
throw new PublishException(
$"Failed to publish message to SNS. Topic ARN: '{request.TopicArn}', Subject: '{request.Subject}', Message: '{request.Message}'.",
ex);
}
}
_logger.LogInformation(
"Published message: '{SnsSubject}' with content {SnsMessage} and request Id '{SnsRequestId}'",
request.Subject,
request.Message,
response?.ResponseMetadata?.RequestId);
if (MessageResponseLogger != null)
{
var responseData = new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId,
ResponseMetadata = response?.ResponseMetadata
};
MessageResponseLogger.Invoke(responseData, message);
}
}
private bool ClientExceptionHandler(Exception ex, Message message) => _snsWriteConfiguration?.HandleException?.Invoke(ex, message) ?? false;
private async Task<bool> CallMessageHandlers(Message message)
{
var handlerFuncs = _handlerMap.Get(message.GetType());
if ((handlerFuncs == null) || (handlerFuncs.Count == 0))
{
return true;
}
bool allHandlersSucceeded;
var watch = System.Diagnostics.Stopwatch.StartNew();
if (handlerFuncs.Count == 1)
{
// a shortcut for the usual case
allHandlersSucceeded = await handlerFuncs[0](message).ConfigureAwait(false);
}
else
{
var handlerTasks = handlerFuncs.Select(func => func(message));
var handlerResults = await Task.WhenAll(handlerTasks).ConfigureAwait(false);
allHandlersSucceeded = handlerResults.All(x => x);
}
watch.Stop();
Log.Trace("Handled message - MessageType: {0}", message.GetType().Name);
_messagingMonitor.HandleTime(watch.ElapsedMilliseconds);
return allHandlersSucceeded;
}
public Task PublishAsync(Message message, CancellationToken cancellationToken) => PublishAsync(message, null, cancellationToken);
public string GetMessageInContext(Message message)
{
return _serialisationRegister.Serialise(message, serializeForSnsPublishing: false);
}
private string GetMessageInContext(Message message)
{
var serializedMessage = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message);
var context = new { Subject = message.GetType().ToKey(), Message = serializedMessage };
return JsonConvert.SerializeObject(context);
}
private async Task UpdateMessageVisibilityTimeout(SQSMessage message, string receiptHandle, Message typedMessage, Exception lastException)
{
if (TryGetApproxReceiveCount(message.Attributes, out int approxReceiveCount))
{
var visibilityTimeout = _messageBackoffStrategy.GetBackoffDuration(typedMessage, approxReceiveCount, lastException);
var visibilityTimeoutSeconds = (int)visibilityTimeout.TotalSeconds;
var visibilityRequest = new ChangeMessageVisibilityRequest
{
QueueUrl = _queue.Uri.AbsoluteUri,
ReceiptHandle = receiptHandle,
VisibilityTimeout = visibilityTimeoutSeconds
};
try
{
await _queue.Client.ChangeMessageVisibilityAsync(visibilityRequest).ConfigureAwait(false);
}
catch (AmazonServiceException ex)
{
_logger.LogError(0, ex, "Failed to update message visibility timeout by {VisibilityTimeout} seconds.", visibilityTimeoutSeconds);
_onError(ex, message);
}
}
}
public string GetMessageInContext(Message message) => _serialisationRegister.Serialise(message, serializeForSnsPublishing: false);
public Task PublishAsync(Message message) => PublishAsync(message, CancellationToken.None);
