public async Task TestQueueClaims()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
QueueStatistics statistics;
using (Claim claim = await provider.ClaimMessageAsync(queueName, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(1), cancellationTokenSource.Token))
{
Assert.AreEqual(TimeSpan.FromMinutes(5), claim.TimeToLive);
Assert.IsNotNull(claim.Messages);
Assert.AreEqual(1, claim.Messages.Count);
statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(1, statistics.MessageStatistics.Claimed);
QueuedMessage message = await provider.GetMessageAsync(queueName, claim.Messages[0].Id, cancellationTokenSource.Token);
Assert.IsNotNull(message);
TimeSpan age = claim.Age;
await Task.Delay(TimeSpan.FromSeconds(2));
await claim.RefreshAsync(cancellationTokenSource.Token);
Assert.IsTrue(claim.Age >= age + TimeSpan.FromSeconds(2));
await claim.RenewAsync(TimeSpan.FromMinutes(10), cancellationTokenSource.Token);
Assert.AreEqual(TimeSpan.FromMinutes(10), claim.TimeToLive);
}
statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(0, statistics.MessageStatistics.Claimed);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
private async Task <int> SubscribeMessages(QueueName requestQueueName, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
int processedMessages = 0;
try
{
while (true)
{
// process request messages
using (Claim claim = await queueingService.ClaimMessageAsync(requestQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), token))
{
List <QueuedMessage> messagesToDelete = new List <QueuedMessage>();
foreach (QueuedMessage queuedMessage in claim.Messages)
{
CalculatorOperation operation = queuedMessage.Body.ToObject <CalculatorOperation>();
CalculatorResult result;
switch (operation._command)
{
case "+":
result = new CalculatorResult(operation, operation._operand1 + operation._operand2);
break;
case "-":
result = new CalculatorResult(operation, operation._operand1 - operation._operand2);
break;
case "*":
result = new CalculatorResult(operation, operation._operand1 * operation._operand2);
break;
case "/":
result = new CalculatorResult(operation, operation._operand1 / operation._operand2);
break;
default:
throw new InvalidOperationException();
}
messagesToDelete.Add(queuedMessage);
// Assigning result to a local suppresses a warning about calling an asynchronous operation.
// In this case, we do not need to wait for the task to finish.
Task postTask = queueingService.PostMessagesAsync(operation._replyQueueName, token, new Message <CalculatorResult>(TimeSpan.FromMinutes(5), result));
processedMessages++;
}
if (messagesToDelete.Count > 0)
{
await queueingService.DeleteMessagesAsync(requestQueueName, messagesToDelete.Select(i => i.Id), token);
}
// start the dispose process using DisposeAsync so the CancellationToken is honored
Task disposeTask = claim.DisposeAsync(token);
}
if (token.IsCancellationRequested)
{
return(processedMessages);
}
}
}
catch (AggregateException ex)
{
ex.Flatten().Handle(
e =>
{
if (e is TaskCanceledException)
{
return(true);
}
WebException webException = e as WebException;
if (webException != null)
{
if (webException.Status == WebExceptionStatus.RequestCanceled)
{
return(true);
}
}
return(false);
});
return(processedMessages);
}
catch (TaskCanceledException)
{
return(processedMessages);
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.RequestCanceled)
{
throw;
}
return(processedMessages);
}
}
private async Task <int> PublishMessages(QueueName requestQueueName, QueueName replyQueueName, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
int processedMessages = 0;
try
{
Random random = new Random();
while (true)
{
long x = random.Next();
long y = random.Next();
Message <CalculatorOperation> message = new Message <CalculatorOperation>(TimeSpan.FromMinutes(5), new CalculatorOperation(replyQueueName, "+", x, y));
await queueingService.PostMessagesAsync(requestQueueName, token, message);
bool handled = false;
while (true)
{
// process reply messages
using (Claim claim = await queueingService.ClaimMessageAsync(replyQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), token))
{
foreach (QueuedMessage queuedMessage in claim.Messages)
{
CalculatorResult result = queuedMessage.Body.ToObject <CalculatorResult>();
if (result._id == message.Body._id)
{
// this is the reply to this thread's operation
Assert.AreEqual(message.Body._operand1 + message.Body._operand2, result._result);
Assert.AreEqual(x + y, result._result);
await queueingService.DeleteMessageAsync(replyQueueName, queuedMessage.Id, claim, token);
processedMessages++;
handled = true;
}
else if (token.IsCancellationRequested)
{
// shutdown trigger
return(processedMessages);
}
}
// start the dispose process using DisposeAsync so the CancellationToken is honored
Task disposeTask = claim.DisposeAsync(token);
}
if (handled)
{
break;
}
}
}
}
catch (AggregateException ex)
{
ex.Flatten().Handle(
e =>
{
if (e is TaskCanceledException)
{
return(true);
}
WebException webException = e as WebException;
if (webException != null)
{
if (webException.Status == WebExceptionStatus.RequestCanceled)
{
return(true);
}
}
return(false);
});
return(processedMessages);
}
catch (TaskCanceledException)
{
return(processedMessages);
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.RequestCanceled)
{
throw;
}
return(processedMessages);
}
}
