public void SynchronousTestListAllQueueMessages()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
for (int i = 0; i < 28; i++)
{
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i)));
}
HashSet <int> locatedMessages = new HashSet <int>();
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, false);
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);
}
provider.DeleteQueue(queueName);
}
private void PublishMessages(QueueName requestQueueName, QueueName replyQueueName, ref int processedMessages, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
processedMessages = 0;
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));
queueingService.PostMessages(requestQueueName, message);
bool handled = false;
while (true)
{
// process reply messages
using (Claim claim = queueingService.ClaimMessage(replyQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)))
{
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);
queueingService.DeleteMessage(replyQueueName, queuedMessage.Id, claim);
processedMessages++;
handled = true;
}
else if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
if (handled)
{
break;
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
public AnalyticsTrackingMiddleware(RequestDelegate next, IAnalyticsHandler handler, IQueueingService queueingService, ILogger <AnalyticsTrackingMiddleware> logger)
{
this.Next = next;
this.Handler = handler;
this.QueueingService = queueingService;
this.Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="Claim"/> class using the provided values.
/// </summary>
/// <param name="service">The queueing service.</param>
/// <param name="queueName">The name of the queue.</param>
/// <param name="location">The absolute URI of the claim resource. If no claim was allocated by the server, this value is <see langword="null"/>.</param>
/// <param name="timeToLive">The time to live of the claim.</param>
/// <param name="age">The age of the claim.</param>
/// <param name="owner"><see langword="true"/> if the current instance owns the claim (and is responsible for releasing it); otherwise, <see langword="false"/>.</param>
/// <param name="messages">A collection of messages belonging to the claim.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="service"/> is <see langword="null"/>.
/// <para>-or-</para>
/// <para>If <paramref name="queueName"/> is <see langword="null"/>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="messages"/> is <see langword="null"/>.</para>
/// </exception>
public Claim(IQueueingService service, QueueName queueName, Uri location, TimeSpan timeToLive, TimeSpan age, bool owner, IEnumerable <QueuedMessage> messages)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
if (queueName == null)
{
throw new ArgumentNullException("queueName");
}
if (messages == null)
{
throw new ArgumentNullException("messages");
}
_service = service;
_queueName = queueName;
_location = location;
_timeToLive = timeToLive;
_age = age;
_messages = messages.ToArray();
if (!owner)
{
// prevent this object from releasing the resource
_releaseTask = InternalTaskExtensions.CompletedTask();
}
}
public void SynchronousTestGetHome()
{
IQueueingService provider = CreateProvider();
HomeDocument document = provider.GetHome();
Assert.IsNotNull(document);
Console.WriteLine(JsonConvert.SerializeObject(document, Formatting.Indented));
}
public async Task TestGetHome()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
HomeDocument document = await provider.GetHomeAsync(cancellationTokenSource.Token);
Assert.IsNotNull(document);
Console.WriteLine(JsonConvert.SerializeObject(document, Formatting.Indented));
}
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 void SynchronousTestQueueExists()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
Assert.IsTrue(provider.QueueExists(queueName));
provider.DeleteQueue(queueName);
Assert.IsFalse(provider.QueueExists(queueName));
}
public void SynchronousCleanupTestQueues()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
CloudQueue[] allQueues = ListAllQueues(provider, null, false).ToArray();
foreach (CloudQueue queue in allQueues)
{
Console.WriteLine("Deleting queue: {0}", queue.Name);
provider.DeleteQueue(queue.Name);
}
}
public async Task TestQueueExists()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
Assert.IsTrue(await provider.QueueExistsAsync(queueName, cancellationTokenSource.Token));
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
Assert.IsFalse(await provider.QueueExistsAsync(queueName, cancellationTokenSource.Token));
}
/// <summary>
/// Gets all existing message queues through a series of synchronous operations,
/// each of which requests a subset of the available queues.
/// </summary>
/// <param name="provider">The queueing service.</param>
/// <param name="limit">The maximum number of <see cref="CloudQueue"/> to return from a single call to <see cref="QueueingServiceExtensions.ListQueues"/>. If this value is <see langword="null"/>, a provider-specific default is used.</param>
/// <param name="detailed"><see langword="true"/> to return detailed information for each queue; otherwise, <see langword="false"/>.</param>
/// <returns>A collection of <see cref="CloudQueue"/> objects describing the available queues.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="provider"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="limit"/> is less than or equal to 0.</exception>
/// <exception cref="WebException">If the REST request does not return successfully.</exception>
private static ReadOnlyCollection <CloudQueue> ListAllQueues(IQueueingService provider, int?limit, bool detailed)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (limit <= 0)
{
throw new ArgumentOutOfRangeException("limit");
}
return(provider.ListQueues(null, limit, detailed).GetAllPages());
}
public QueueProcessorService(
IServiceProvider serviceProvider,
IQueueingService queueingService,
IOptions <AnalyticsServerOptions> optionsAccessor,
ILogger <QueueProcessorService> logger)
{
this.ServiceProvider = serviceProvider;
this.Options = optionsAccessor.Value;
this.QueueingService = queueingService;
this.Logger = logger;
this.ProcessorTasks = new Task[this.Options.ProcessorThreadCount];
}
public void SynchronousTestListQueues()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
foreach (CloudQueue queue in ListAllQueues(provider, null, true))
{
Console.WriteLine("{0}: {1}", queue.Name, queue.Href);
}
provider.DeleteQueue(queueName);
}
public void SynchronousCleanupTestQueues()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
CloudQueue[] allQueues = ListAllQueues(provider, null, false).ToArray();
IEnumerable <CloudQueue> testQueues = allQueues.Where(queue => queue.Name != null && queue.Name.Value.StartsWith(TestQueuePrefix));
foreach (CloudQueue queue in testQueues)
{
Console.WriteLine("Deleting queue: {0}", queue.Name);
provider.DeleteQueue(queue.Name);
}
}
public void SynchronousTestListAllQueueMessagesWithUpdates()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
for (int i = 0; i < 28; i++)
{
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i)));
}
HashSet <int> locatedMessages = new HashSet <int>();
QueuedMessageList messages = provider.ListMessages(queueName, null, null, true, false);
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;
provider.DeleteMessage(queueName, messages[0].Id, null);
while (messages.Count > 0)
{
QueuedMessageList tempList = provider.ListMessages(queueName, messages.NextPageId, null, true, false);
if (tempList.Count > 0)
{
Assert.IsTrue(locatedMessages.Add(tempList[0].Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once.");
provider.DeleteMessage(queueName, tempList[0].Id, null);
}
messages = provider.ListMessages(queueName, messages.NextPageId, null, true, false);
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);
}
provider.DeleteQueue(queueName);
}
public async Task CleanupTestQueues()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)));
QueueName queueName = CreateRandomQueueName();
ReadOnlyCollection <CloudQueue> allQueues = await ListAllQueuesAsync(provider, null, false, cancellationTokenSource.Token, null);
Task[] deleteTasks = Array.ConvertAll(allQueues.ToArray(), queue =>
{
Console.WriteLine("Deleting queue: {0}", queue.Name);
return(provider.DeleteQueueAsync(queue.Name, cancellationTokenSource.Token));
});
Task.WaitAll(deleteTasks);
}
public async Task TestListQueues()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
foreach (CloudQueue queue in await ListAllQueuesAsync(provider, null, true, cancellationTokenSource.Token, null))
{
Console.WriteLine("{0}: {1}", queue.Name, queue.Href);
}
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public void SynchronousTestCreateQueue()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
bool created = provider.CreateQueue(queueName);
Assert.IsTrue(created);
bool recreated = provider.CreateQueue(queueName);
Assert.IsFalse(recreated);
provider.DeleteQueue(queueName);
}
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);
}
}
public void SynchronousTestPostQueueMessages_Generic_2()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
Message genericMessage = new Message(TimeSpan.FromMinutes(50), new JObject(new JProperty("type", "generic")));
//
// Generic messages
//
enqueued = provider.PostMessages(queueName, genericMessage, genericMessage);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(2, enqueued.Ids.Count());
Assert.AreEqual(false, enqueued.Partial);
enqueued = provider.PostMessages(queueName, new[] { genericMessage, genericMessage });
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(2, enqueued.Ids.Count());
Assert.AreEqual(false, enqueued.Partial);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(4, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
public void SynchronousTestPostQueueMessages_Typed_0()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
Message <SampleMetadata> typedMessage = new Message <SampleMetadata>(TimeSpan.FromMinutes(40), new SampleMetadata(1, "Stuff!"));
//
// Typed messages
//
enqueued = provider.PostMessages <SampleMetadata>(queueName);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
enqueued = provider.PostMessages <SampleMetadata>(queueName, Enumerable.Empty <Message <SampleMetadata> >());
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(0, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
/// <summary>
/// Gets all existing messages in a queue through a series of synchronous operations,
/// each of which requests a subset of the available messages.
/// </summary>
/// <param name="provider">The queueing service.</param>
/// <param name="queueName">The queue name.</param>
/// <param name="limit">The maximum number of <see cref="QueuedMessage"/> objects to return from a single task. If this value is <see langword="null"/>, a provider-specific default is used.</param>
/// <param name="echo"><see langword="true"/> to include messages created by the current client; otherwise, <see langword="false"/>.</param>
/// <param name="includeClaimed"><see langword="true"/> to include claimed messages; otherwise <see langword="false"/> to return only unclaimed messages.</param>
/// <param name="progress">An optional callback object to receive progress notifications. If this is <see langword="null"/>, no progress notifications are sent.</param>
/// <returns>A collection of <see cref="CloudQueue"/> objects describing the available queues.</returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="provider"/> is <see langword="null"/>.
/// <para>-or-</para>
/// <para>If <paramref name="queueName"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="limit"/> is less than or equal to 0.</exception>
/// <exception cref="WebException">If the REST request does not return successfully.</exception>
private static ReadOnlyCollection <QueuedMessage> ListAllMessages(IQueueingService provider, QueueName queueName, int?limit, bool echo, bool includeClaimed)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (queueName == null)
{
throw new ArgumentNullException("queueName");
}
if (limit <= 0)
{
throw new ArgumentOutOfRangeException("limit");
}
return(provider.ListMessages(queueName, null, limit, echo, includeClaimed).GetAllPages());
}
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);
}
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 void SynchronousTestPostQueueMessages_Generic_0()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
//
// Generic messages
//
enqueued = provider.PostMessages(queueName);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
enqueued = provider.PostMessages(queueName, Enumerable.Empty <Message>());
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(0, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
public void SynchronousTestQueueMetadataDynamic()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
JObject metadata = new JObject(
new JProperty("valueA", 3),
new JProperty("valueB", "yes"));
provider.SetQueueMetadata(queueName, metadata);
JObject result = provider.GetQueueMetadata(queueName);
Assert.AreEqual(3, result["valueA"]);
Assert.AreEqual("yes", result["valueB"]);
provider.DeleteQueue(queueName);
}
public void SynchronousTestQueueStatistics()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
QueueStatistics statistics = provider.GetQueueStatistics(queueName);
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));
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
statistics = provider.GetQueueStatistics(queueName);
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));
provider.DeleteQueue(queueName);
}
public void SynchronousTestQueueMetadataStatic()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
SampleMetadata metadata = new SampleMetadata(3, "yes");
Assert.AreEqual(3, metadata.ValueA);
Assert.AreEqual("yes", metadata.ValueB);
provider.SetQueueMetadata(queueName, metadata);
SampleMetadata result = provider.GetQueueMetadata <SampleMetadata>(queueName);
Assert.AreEqual(metadata.ValueA, result.ValueA);
Assert.AreEqual(metadata.ValueB, result.ValueB);
provider.DeleteQueue(queueName);
}
public async Task TestQueueMetadataDynamic()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
JObject metadata = new JObject(
new JProperty("valueA", 3),
new JProperty("valueB", "yes"));
await provider.SetQueueMetadataAsync(queueName, metadata, cancellationTokenSource.Token);
JObject result = await provider.GetQueueMetadataAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(3, result["valueA"]);
Assert.AreEqual("yes", result["valueB"]);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestQueueMetadataStatic()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
SampleMetadata metadata = new SampleMetadata(3, "yes");
Assert.AreEqual(3, metadata.ValueA);
Assert.AreEqual("yes", metadata.ValueB);
await provider.SetQueueMetadataAsync(queueName, metadata, cancellationTokenSource.Token);
SampleMetadata result = await provider.GetQueueMetadataAsync <SampleMetadata>(queueName, cancellationTokenSource.Token);
Assert.AreEqual(metadata.ValueA, result.ValueA);
Assert.AreEqual(metadata.ValueB, result.ValueB);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
/// <summary>
/// Initializes a new instance of the <see cref="Claim"/> class using the provided values.
/// </summary>
/// <param name="service">The queueing service.</param>
/// <param name="queueName">The name of the queue.</param>
/// <param name="location">The absolute URI of the claim resource. If no claim was allocated by the server, this value is <see langword="null"/>.</param>
/// <param name="timeToLive">The time to live of the claim.</param>
/// <param name="age">The age of the claim.</param>
/// <param name="owner"><see langword="true"/> if the current instance owns the claim (and is responsible for releasing it); otherwise, <see langword="false"/>.</param>
/// <param name="messages">A collection of messages belonging to the claim.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="service"/> is <see langword="null"/>.
/// <para>-or-</para>
/// <para>If <paramref name="queueName"/> is <see langword="null"/>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="messages"/> is <see langword="null"/>.</para>
/// </exception>
public Claim(IQueueingService service, QueueName queueName, Uri location, TimeSpan timeToLive, TimeSpan age, bool owner, IEnumerable<QueuedMessage> messages)
{
if (service == null)
throw new ArgumentNullException("service");
if (queueName == null)
throw new ArgumentNullException("queueName");
if (messages == null)
throw new ArgumentNullException("messages");
_service = service;
_queueName = queueName;
_location = location;
_timeToLive = timeToLive;
_age = age;
_messages = messages.ToArray();
if (!owner)
{
// prevent this object from releasing the resource
_releaseTask = InternalTaskExtensions.CompletedTask();
}
}
/// <summary>
/// Gets all existing message queues through a series of synchronous operations,
/// each of which requests a subset of the available queues.
/// </summary>
/// <param name="provider">The queueing service.</param>
/// <param name="limit">The maximum number of <see cref="CloudQueue"/> to return from a single call to <see cref="QueueingServiceExtensions.ListQueues"/>. If this value is <see langword="null"/>, a provider-specific default is used.</param>
/// <param name="detailed"><see langword="true"/> to return detailed information for each queue; otherwise, <see langword="false"/>.</param>
/// <returns>A collection of <see cref="CloudQueue"/> objects describing the available queues.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="provider"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="limit"/> is less than or equal to 0.</exception>
/// <exception cref="WebException">If the REST request does not return successfully.</exception>
private static ReadOnlyCollection<CloudQueue> ListAllQueues(IQueueingService provider, int? limit, bool detailed)
{
if (provider == null)
throw new ArgumentNullException("provider");
if (limit <= 0)
throw new ArgumentOutOfRangeException("limit");
return provider.ListQueues(null, limit, detailed).GetAllPages();
}
/// <summary>
/// Gets all existing message queues through a series of synchronous operations,
/// each of which requests a subset of the available queues.
/// </summary>
/// <param name="provider">The queueing service.</param>
/// <param name="limit">The maximum number of <see cref="CloudQueue"/> to return from a single call to <see cref="QueueingServiceExtensions.ListQueues"/>. If this value is <c>null</c>, a provider-specific default is used.</param>
/// <param name="detailed"><c>true</c> to return detailed information for each queue; otherwise, <c>false</c>.</param>
/// <returns>A collection of <see cref="CloudQueue"/> objects describing the available queues.</returns>
private static IEnumerable<CloudQueue> ListAllQueues(IQueueingService provider, int? limit, bool detailed)
{
if (limit <= 0)
throw new ArgumentOutOfRangeException("limit");
CloudQueue lastQueue = null;
do
{
QueueName marker = lastQueue != null ? lastQueue.Name : null;
IEnumerable<CloudQueue> queues = provider.ListQueues(marker, limit, detailed);
lastQueue = null;
foreach (CloudQueue queue in queues)
{
lastQueue = queue;
yield return queue;
}
} while (lastQueue != null);
}
/// <summary>
/// Gets all existing messages in a queue through a series of synchronous operations,
/// each of which requests a subset of the available messages.
/// </summary>
/// <param name="provider">The queueing service.</param>
/// <param name="queueName">The queue name.</param>
/// <param name="limit">The maximum number of <see cref="QueuedMessage"/> objects to return from a single task. If this value is <see langword="null"/>, a provider-specific default is used.</param>
/// <param name="echo"><see langword="true"/> to include messages created by the current client; otherwise, <see langword="false"/>.</param>
/// <param name="includeClaimed"><see langword="true"/> to include claimed messages; otherwise <see langword="false"/> to return only unclaimed messages.</param>
/// <param name="progress">An optional callback object to receive progress notifications. If this is <see langword="null"/>, no progress notifications are sent.</param>
/// <returns>A collection of <see cref="CloudQueue"/> objects describing the available queues.</returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="provider"/> is <see langword="null"/>.
/// <para>-or-</para>
/// <para>If <paramref name="queueName"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="limit"/> is less than or equal to 0.</exception>
/// <exception cref="WebException">If the REST request does not return successfully.</exception>
private static ReadOnlyCollection<QueuedMessage> ListAllMessages(IQueueingService provider, QueueName queueName, int? limit, bool echo, bool includeClaimed)
{
if (provider == null)
throw new ArgumentNullException("provider");
if (queueName == null)
throw new ArgumentNullException("queueName");
if (limit <= 0)
throw new ArgumentOutOfRangeException("limit");
return provider.ListMessages(queueName, null, limit, echo, includeClaimed).GetAllPages();
}
/// <summary>
/// Gets all existing message queues through a series of asynchronous operations,
/// each of which requests a subset of the available queues.
/// </summary>
/// <remarks>
/// Each of the returned tasks is executed asynchronously but sequentially. This
/// method will not send concurrent requests to the queueing service.
/// <para>
/// Due to the way the list end is detected, the final task will return an empty
/// collection of <see cref="CloudQueue"/> instances.
/// </para>
/// </remarks>
/// <param name="provider">The queueing service.</param>
/// <param name="limit">The maximum number of <see cref="CloudQueue"/> to return from a single task. If this value is <c>null</c>, a provider-specific default is used.</param>
/// <param name="detailed"><c>true</c> to return detailed information for each queue; otherwise, <c>false</c>.</param>
/// <returns>
/// A collections of <see cref="Task{TResult}"/> objects, each of which
/// represents an asynchronous operation to gather a subset of the available
/// queues.
/// </returns>
private static IEnumerable<Task<IEnumerable<CloudQueue>>> ListAllQueuesAsync(IQueueingService provider, int? limit, bool detailed, CancellationToken cancellationToken)
{
if (limit <= 0)
throw new ArgumentOutOfRangeException("limit");
CloudQueue lastQueue = null;
do
{
QueueName marker = lastQueue != null ? lastQueue.Name : null;
Task<IEnumerable<CloudQueue>> queues = provider.ListQueuesAsync(marker, limit, detailed, cancellationToken);
lastQueue = null;
yield return queues.ContinueWith(task =>
{
return task.Result.Select(queue =>
{
lastQueue = queue;
return queue;
});
});
} while (lastQueue != null);
}
