public async Task <QueueDescription> CreateQueue(QueueDescription queueDescription)
{
var create = true;
try
{
queueDescription = await _namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
var created = false;
try
{
LogContext.Debug?.Log("Creating queue {Queue}", queueDescription.Path);
queueDescription = await _namespaceManager.CreateQueueAsync(queueDescription).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
{
throw;
}
}
if (!created)
{
queueDescription = await _namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
}
}
LogContext.Debug?.Log("Queue: {Queue} ({Attributes})", queueDescription.Path,
string.Join(", ",
new[]
{
queueDescription.EnableExpress ? "express" : "",
queueDescription.RequiresDuplicateDetection ? "dupe detect" : "",
queueDescription.EnableDeadLetteringOnMessageExpiration ? "dead letter" : "",
queueDescription.RequiresSession ? "session" : ""
}.Where(x => !string.IsNullOrWhiteSpace(x))));
return(queueDescription);
}
public async Task Disable(string queueName)
{
var queue = await _namespaceManager.GetQueueAsync(queueName);
if (queue.Status == EntityStatus.Disabled)
{
return;
}
queue.Status = EntityStatus.Disabled;
await _namespaceManager.UpdateQueueAsync(queue);
}
public async Task <long> AddWordToQueueAsync(QueueClient queueClient, string queueName, string word)
{
Debug.Assert(null != _namespaceManager);
var message = new BrokeredMessage(word);
await queueClient.SendAsync(message).ConfigureAwait(false);
var queue = await _namespaceManager.GetQueueAsync(queueName).ConfigureAwait(false);
return(queue.MessageCount);
}
async Task <IEnumerable <QueueDescription> > SetupSagaTopologyAsync(NamespaceManager nm)
{
Console.WriteLine("Setup");
return(new List <QueueDescription>
{
await nm.QueueExistsAsync(SagaResultQueueName)
? await nm.GetQueueAsync(SagaResultQueueName)
: await nm.CreateQueueAsync(SagaResultQueueName),
await nm.QueueExistsAsync(CancelFlightQueueName)
? await nm.GetQueueAsync(CancelFlightQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelFlightQueueName)),
await nm.QueueExistsAsync(BookFlightQueueName)
? await nm.GetQueueAsync(BookFlightQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookFlightQueueName)
{
// on failure, we move deadletter messages off to the flight
// booking compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelFlightQueueName
}),
await nm.QueueExistsAsync(CancelHotelQueueName)
? await nm.GetQueueAsync(CancelHotelQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelHotelQueueName)),
await nm.QueueExistsAsync(BookHotelQueueName)
? await nm.GetQueueAsync(BookHotelQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookHotelQueueName)
{
// on failure, we move deadletter messages off to the hotel
// booking compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelHotelQueueName
}),
await nm.QueueExistsAsync(CancelRentalCarQueueName)
? await nm.GetQueueAsync(CancelRentalCarQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelRentalCarQueueName)),
await nm.QueueExistsAsync(BookRentalCarQueueName)
? await nm.GetQueueAsync(BookRentalCarQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookRentalCarQueueName)
{
// on failure, we move deadletter messages off to the car rental
// compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelRentalCarQueueName
}),
await nm.QueueExistsAsync(SagaInputQueueName)
? await nm.GetQueueAsync(SagaInputQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(SagaInputQueueName)
{
// book car is the first step
ForwardTo = BookRentalCarQueueName
})
});
}
private async Task <QueueDescription> GetOrCreateQueueDescriptionAsync()
{
try
{
return(await _namespaceManager.GetQueueAsync(_path).ConfigureAwait(false));
}
catch (MessagingEntityNotFoundException)
{
return(await _namespaceManager.CreateQueueAsync(_path).ConfigureAwait(false));
}
}
protected override async Task <QueueStats> GetQueueStatsImplAsync()
{
var q = await _namespaceManager.GetQueueAsync(_options.Name).AnyContext();
return(new QueueStats {
Queued = q.MessageCount,
Working = 0,
Deadletter = q.MessageCountDetails.DeadLetterMessageCount,
Enqueued = _enqueuedCount,
Dequeued = _dequeuedCount,
Completed = _completedCount,
Abandoned = _abandonedCount,
Errors = _workerErrorCount,
Timeouts = 0
});
}
private async Task <bool> QueueUpdateEntityStatusAsync(
string queueName,
EntityStatus entityStatus)
{
bool statusChanged = false;
try
{
if (namespaceManager.QueueExists(queueName))
{
var queue = await namespaceManager.GetQueueAsync(queueName);
var queueStatus = queue.Status;
if (queueStatus != entityStatus)
{
var queueDescription = new QueueDescription(queueName)
{
Status = entityStatus
};
await namespaceManager.UpdateQueueAsync(queueDescription);
statusChanged = true;
logger.LogInformation($"Queue {queueName} changed status from {queueStatus} to {entityStatus}.");
}
}
else
{
logger.LogCritical($"Failed to change status for queue {queueName} to {entityStatus}. Queue does not exist.");
}
}
catch (Exception ex)
{
logger.LogCritical(ex, $"Failed to change status for queue {queueName} to {entityStatus}.");
}
return(statusChanged);
}
private async Task <QueueDescription> GetQueueDescriptionAsync()
{
return(await RetryPolicy.ExecuteAsync(async() => await NamespaceManager.GetQueueAsync(Client.Path)));
}
protected override async Task EnsureQueueCreatedAsync(CancellationToken cancellationToken = new CancellationToken())
{
if (_queueClient != null)
{
return;
}
using (await _lock.LockAsync(cancellationToken).AnyContext()) {
if (_queueClient != null)
{
return;
}
QueueDescription queueDescription;
if (!await _namespaceManager.QueueExistsAsync(_queueName).AnyContext())
{
try {
queueDescription = await _namespaceManager.CreateQueueAsync(new QueueDescription(_queueName) {
MaxDeliveryCount = _retries + 1,
LockDuration = _workItemTimeout,
AutoDeleteOnIdle = _autoDeleteOnIdle,
DefaultMessageTimeToLive = _defaultMessageTimeToLive
}).AnyContext();
}
catch (MessagingException) {
queueDescription = await _namespaceManager.GetQueueAsync(_queueName).AnyContext();
}
}
else
{
queueDescription = await _namespaceManager.GetQueueAsync(_queueName).AnyContext();
bool changes = false;
int newMaxDeliveryCount = _retries + 1;
if (queueDescription.MaxDeliveryCount != newMaxDeliveryCount)
{
queueDescription.MaxDeliveryCount = newMaxDeliveryCount;
changes = true;
}
if (queueDescription.LockDuration != _workItemTimeout)
{
queueDescription.LockDuration = _workItemTimeout;
changes = true;
}
if (queueDescription.AutoDeleteOnIdle != _autoDeleteOnIdle)
{
queueDescription.AutoDeleteOnIdle = _autoDeleteOnIdle;
changes = true;
}
if (queueDescription.DefaultMessageTimeToLive != _defaultMessageTimeToLive)
{
queueDescription.DefaultMessageTimeToLive = _defaultMessageTimeToLive;
changes = true;
}
if (changes)
{
await _namespaceManager.UpdateQueueAsync(queueDescription).AnyContext();
}
}
_queueClient = QueueClient.CreateFromConnectionString(_connectionString, queueDescription.Path);
if (_retryPolicy != null)
{
_queueClient.RetryPolicy = _retryPolicy;
}
}
}
private async Task <QueueDescription> GetQueueAsync()
{
return(await NamespaceManager.GetQueueAsync(QueueName));
}
public async Task <long> GetMessageCount()
{
var queue = await _namespaceManager.GetQueueAsync(_queueName);
return(queue.MessageCount);
}
public static async Task <QueueDescription> CreateQueueSafeAsync(this NamespaceManager namespaceManager, QueueDescription queueDescription)
{
bool create = true;
try
{
queueDescription = await namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
bool created = false;
try
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Creating queue {0}", queueDescription.Path);
}
queueDescription = await namespaceManager.CreateQueueAsync(queueDescription).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
{
throw;
}
}
if (!created)
{
queueDescription = await namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
}
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Queue: {0} ({1})", queueDescription.Path,
string.Join(", ", new[]
{
queueDescription.EnableExpress ? "express" : "",
queueDescription.RequiresDuplicateDetection ? "dupe detect" : "",
queueDescription.EnableDeadLetteringOnMessageExpiration ? "dead letter" : ""
}.Where(x => !string.IsNullOrWhiteSpace(x))));
}
return(queueDescription);
}
public async Task <QueueDescription> GetQueueAsync(string path)
{
return(await _namespaceManager.GetQueueAsync(path));
}
async Task<IEnumerable<QueueDescription>> SetupSagaTopologyAsync(NamespaceManager nm)
{
Console.WriteLine("Setup");
return new List<QueueDescription>
{
await nm.QueueExistsAsync(SagaResultQueueName)
? await nm.GetQueueAsync(SagaResultQueueName)
: await nm.CreateQueueAsync(SagaResultQueueName),
await nm.QueueExistsAsync(CancelFlightQueueName)
? await nm.GetQueueAsync(CancelFlightQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelFlightQueueName)),
await nm.QueueExistsAsync(BookFlightQueueName)
? await nm.GetQueueAsync(BookFlightQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookFlightQueueName)
{
// on failure, we move deadletter messages off to the flight
// booking compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelFlightQueueName
}),
await nm.QueueExistsAsync(CancelHotelQueueName)
? await nm.GetQueueAsync(CancelHotelQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelHotelQueueName)),
await nm.QueueExistsAsync(BookHotelQueueName)
? await nm.GetQueueAsync(BookHotelQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookHotelQueueName)
{
// on failure, we move deadletter messages off to the hotel
// booking compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelHotelQueueName
}),
await nm.QueueExistsAsync(CancelRentalCarQueueName)
? await nm.GetQueueAsync(CancelRentalCarQueueName)
: await nm.CreateQueueAsync(new QueueDescription(CancelRentalCarQueueName)),
await nm.QueueExistsAsync(BookRentalCarQueueName)
? await nm.GetQueueAsync(BookRentalCarQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(BookRentalCarQueueName)
{
// on failure, we move deadletter messages off to the car rental
// compensator's queue
EnableDeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = CancelRentalCarQueueName
}),
await nm.QueueExistsAsync(SagaInputQueueName)
? await nm.GetQueueAsync(SagaInputQueueName)
: await nm.CreateQueueAsync(
new QueueDescription(SagaInputQueueName)
{
// book car is the first step
ForwardTo = BookRentalCarQueueName
})
};
}
public Task <QueueDescription> GetQueue(string path)
{
return(manager.GetQueueAsync(path));
}
