public async Task TestListAllQueueMessagesWithUpdates() { IQueueingService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)))) { QueueName queueName = CreateRandomQueueName(); await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token); List <Task> postMessagesTasks = new List <Task>(); for (int i = 0; i < 28; i++) { postMessagesTasks.Add(provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i)))); } await Task.Factory.ContinueWhenAll(postMessagesTasks.ToArray(), TaskExtrasExtensions.PropagateExceptions); HashSet <int> locatedMessages = new HashSet <int>(); QueuedMessageList messages = await provider.ListMessagesAsync(queueName, null, null, true, false, cancellationTokenSource.Token); foreach (QueuedMessage message in messages) { Assert.IsTrue(locatedMessages.Add(message.Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once."); } int deletedMessage = messages[0].Body.ToObject <SampleMetadata>().ValueA; await provider.DeleteMessageAsync(queueName, messages[0].Id, null, cancellationTokenSource.Token); while (messages.Count > 0) { QueuedMessageList tempList = await provider.ListMessagesAsync(queueName, messages.NextPageId, null, true, false, cancellationTokenSource.Token); if (tempList.Count > 0) { Assert.IsTrue(locatedMessages.Add(tempList[0].Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once."); await provider.DeleteMessageAsync(queueName, tempList[0].Id, null, cancellationTokenSource.Token); } messages = await provider.ListMessagesAsync(queueName, messages.NextPageId, null, true, false, cancellationTokenSource.Token); foreach (QueuedMessage message in messages) { Assert.IsTrue(locatedMessages.Add(message.Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once."); } } Assert.AreEqual(28, locatedMessages.Count); for (int i = 0; i < 28; i++) { Assert.IsTrue(locatedMessages.Contains(i), "The message listing did not include message '{0}', which was in the queue when the listing started and still in it afterwards.", i); } await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token); } }
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); }
public async Task TestQueueStatistics() { IQueueingService provider = CreateProvider(); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10))); QueueName queueName = CreateRandomQueueName(); await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token); QueueStatistics statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token); Assert.IsNotNull(statistics); QueueMessagesStatistics messageStatistics = statistics.MessageStatistics; Assert.IsNotNull(messageStatistics); Assert.AreEqual(messageStatistics.Free, 0); Assert.AreEqual(messageStatistics.Claimed, 0); Assert.AreEqual(messageStatistics.Total, 0); Assert.IsNull(messageStatistics.Oldest); Assert.IsNull(messageStatistics.Newest); Console.WriteLine("Statistics:"); Console.WriteLine(); Console.WriteLine(JsonConvert.SerializeObject(statistics, Formatting.Indented)); await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes"))); statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token); Assert.IsNotNull(statistics); messageStatistics = statistics.MessageStatistics; Assert.IsNotNull(messageStatistics); Assert.AreEqual(messageStatistics.Free, 1); Assert.AreEqual(messageStatistics.Claimed, 0); Assert.AreEqual(messageStatistics.Total, 1); Assert.IsNotNull(messageStatistics.Oldest); Assert.IsNotNull(messageStatistics.Newest); Console.WriteLine("Statistics:"); Console.WriteLine(); Console.WriteLine(JsonConvert.SerializeObject(statistics, Formatting.Indented)); 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); } }
public async Task TestPostQueueMessages() { IQueueingService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)))) { QueueName queueName = CreateRandomQueueName(); await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token); JObject genericBody = new JObject( new JProperty("type", "generic")); Message genericMessage = new Message(TimeSpan.FromMinutes(50), genericBody); await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token); await provider.PostMessagesAsync(queueName, Enumerable.Empty <Message>(), cancellationTokenSource.Token); await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, genericMessage); await provider.PostMessagesAsync(queueName, new[] { genericMessage }, cancellationTokenSource.Token); await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, genericMessage, genericMessage); await provider.PostMessagesAsync(queueName, new[] { genericMessage, genericMessage }, cancellationTokenSource.Token); Message <SampleMetadata> typedMessage = new Message <SampleMetadata>(TimeSpan.FromMinutes(40), new SampleMetadata(1, "Stuff!")); await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token); await provider.PostMessagesAsync <SampleMetadata>(queueName, Enumerable.Empty <Message <SampleMetadata> >(), cancellationTokenSource.Token); await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token, typedMessage); await provider.PostMessagesAsync <SampleMetadata>(queueName, new[] { typedMessage }, cancellationTokenSource.Token); await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token, typedMessage, typedMessage); await provider.PostMessagesAsync <SampleMetadata>(queueName, new[] { typedMessage, typedMessage }, cancellationTokenSource.Token); ReadOnlyCollection <QueuedMessage> messages = await ListAllMessagesAsync(provider, queueName, null, true, true, cancellationTokenSource.Token, null); Assert.IsNotNull(messages); Assert.AreEqual(12, messages.Count); await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token); } }