protected override async Task WhenAsync()
{
var metadata = new PublishMetadata()
.AddMessageAttribute(MessageAttributeKey, MessageAttributeValue);
await SystemUnderTest.PublishAsync(new SimpleMessage(), metadata);
}
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 with subject '{MessageSubject}' and content '{MessageBody}'.",
request.Subject,
request.Message);
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, PublishMetadata metadata, CancellationToken cancellationToken)
{
var publisher = GetActivePublisherForMessage(message);
await PublishAsync(publisher, message, metadata, 0, cancellationToken)
.ConfigureAwait(false);
}
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);
}
Logger.LogInformation(
"Published message to queue '{QueueUrl}' with content '{MessageBody}'.",
request.QueueUrl,
request.MessageBody);
if (MessageResponseLogger != null)
{
var responseData = new MessageResponse
{
HttpStatusCode = response?.HttpStatusCode,
MessageId = response?.MessageId,
ResponseMetadata = response?.ResponseMetadata
};
MessageResponseLogger.Invoke(responseData, message);
}
}
/// <summary>
/// Publish a message to the stack, asynchronously.
/// </summary>
/// <param name="message"></param>
/// <param name="cancellationToken"></param>
public virtual async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken)
{
if (Bus == null)
{
throw new InvalidOperationException("You must register for message publication before publishing a message");
}
await Bus.PublishAsync(message, metadata, cancellationToken)
.ConfigureAwait(false);
}
private static Dictionary <string, MessageAttributeValue> BuildMessageAttributes(PublishMetadata metadata)
{
if (metadata?.MessageAttributes == null || metadata.MessageAttributes.Count == 0)
{
return(null);
}
return(metadata.MessageAttributes.ToDictionary(
source => source.Key,
source => BuildMessageAttributeValue(source.Value)));
}
public static async Task PublishAsync(this IMessagePublisher publisher,
Message message, PublishMetadata metadata)
{
if (publisher == null)
{
throw new ArgumentNullException(nameof(publisher));
}
await publisher.PublishAsync(message, metadata, CancellationToken.None)
.ConfigureAwait(false);
}
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 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 async Task PublishAsync(
Message message,
PublishMetadata metadata,
CancellationToken cancellationToken)
{
if (!_busStarted)
{
throw new InvalidOperationException("Bus must be started before publishing messages.");
}
IMessagePublisher publisher = GetPublisherForMessage(message);
await PublishAsync(publisher, message, metadata, 0, cancellationToken)
.ConfigureAwait(false);
}
public async Task PublishAsync(
Message message,
PublishMetadata metadata,
CancellationToken cancellationToken)
{
if (!_busStarted && _startupTasks.Count > 0)
{
throw new InvalidOperationException("There are pending startup tasks that must be executed by calling StartAsync before messages may be published.");
}
IMessagePublisher publisher = GetPublisherForMessage(message);
await PublishAsync(publisher, message, metadata, 0, cancellationToken)
.ConfigureAwait(false);
}
private async Task PublishAsync(
IMessagePublisher publisher,
Message message,
PublishMetadata metadata,
int attemptCount,
CancellationToken cancellationToken)
{
attemptCount++;
try
{
using (Monitor.MeasurePublish())
{
await publisher.PublishAsync(message, metadata, cancellationToken)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
var messageType = message.GetType();
if (attemptCount >= Config.PublishFailureReAttempts)
{
Monitor.IssuePublishingMessage();
_log.LogError(
ex,
"Failed to publish a message of type '{MessageType}'. Halting after attempt number {PublishAttemptCount}.",
messageType,
attemptCount);
throw;
}
_log.LogWarning(
ex,
"Failed to publish a message of type '{MessageType}'. Retrying after attempt number {PublishAttemptCount} of {PublishFailureReattempts}.",
messageType,
attemptCount,
Config.PublishFailureReAttempts);
var delayForAttempt =
TimeSpan.FromMilliseconds(Config.PublishFailureBackoff.TotalMilliseconds * attemptCount);
await Task.Delay(delayForAttempt, cancellationToken).ConfigureAwait(false);
await PublishAsync(publisher, message, metadata, attemptCount, cancellationToken)
.ConfigureAwait(false);
}
}
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);
}
}
// Imports a directory into the repository. 'serverPath' is the relative path in the repository.
// 'localPath' is the local directory to publish. 'files' is the list of files to add to the new
// repository directory (must use absolute local paths).
public Repository Publish(string serverPath, FilePath localPath, FilePath[] files, string message, ProgressMonitor monitor)
{
var metadata = new PublishMetadata(VersionControlSystem)
{
PathsCount = files.Length, SubFolder = localPath.IsChildPathOf(RootPath)
};
using (var tracker = Instrumentation.PublishCounter.BeginTiming(metadata, monitor.CancellationToken)) {
try {
var res = OnPublish(serverPath, localPath, files, message, monitor);
ClearCachedVersionInfo(localPath);
return(res);
} catch {
metadata.SetFailure();
throw;
}
}
}
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 Dictionary <string, object>
{
["AwsRequestId"] = response?.MessageId
}))
{
_logger.LogInformation(
"Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.",
message.Id,
message.GetType().FullName,
"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, 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);
}
}
