private static async Task UpdateEnqueuedMessageAsync(CloudQueue queue)
{
Console.WriteLine("5. Insert another test message ");
await queue.AddMessageAsync(new CloudQueueMessage("Hello World Again!"));
Console.WriteLine("6. Change the contents of a queued message");
CloudQueueMessage message = await queue.GetMessageAsync();
message.SetMessageContent("Updated contents.");
await queue.UpdateMessageAsync(message, TimeSpan.Zero, MessageUpdateFields.Content | MessageUpdateFields.Visibility);
}
private static async Task BasicQueueOperationsAsync(CloudQueue queue)
{
Console.WriteLine("2. Insert a single message into a queue");
await queue.AddMessageAsync(new CloudQueueMessage("Hello World!"));
Console.WriteLine("3. Peek at the next message");
CloudQueueMessage peekedMessage = await queue.PeekMessageAsync();
if (peekedMessage != null)
{
Console.WriteLine("The peeked message is: {0}", peekedMessage.AsString);
}
Console.WriteLine("4. De-queue the next message");
CloudQueueMessage message = await queue.GetMessageAsync();
if (message != null)
{
Console.WriteLine("Processing & deleting message with content: {0}", message.AsString);
await queue.DeleteMessageAsync(message);
}
}
/// <inheritdoc />
public async Task AddMessagesAsync(CloudQueue queue, IEnumerable<CloudQueueMessage> messages)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
try
{
List<Task> addTasks = new List<Task>();
foreach (var message in messages)
{
Task addTask = queue.AddMessageAsync(message);
addTasks.Add(addTask);
}
await Task.WhenAll(addTasks);
}
catch (Exception ex)
{
string errorMessage = GetStorageErrorMessage(ex);
int statusCode = GetStorageStatusCode(ex);
string msg = string.Format(CultureInfo.CurrentCulture, AzureStorageResources.StorageManager_OperationFailed, statusCode, errorMessage);
_logger.Error(msg, ex);
}
}
/// <summary>
/// Demonstrate adding a number of messages, checking the message count and batch retrieval of messages. During retrieval we
/// also set the visibility timeout to 5 minutes. Visibility timeout is the amount of time message is not visible to other
/// clients after a GetMessageOperation assuming DeleteMessage is not called.
/// </summary>
/// <param name="queue">The sample queue</param>
private static async Task ProcessBatchOfMessagesAsync(CloudQueue queue)
{
// Enqueue 20 messages by which to demonstrate batch retrieval
Console.WriteLine("7. Enqueue 20 messages.");
for (int i = 0; i < 20; i++)
{
await queue.AddMessageAsync(new CloudQueueMessage(string.Format("{0} - {1}", i, "Hello World")));
}
// The FetchAttributes method asks the Queue service to retrieve the queue attributes, including an approximation of message count
Console.WriteLine("8. Get the queue length");
queue.FetchAttributes();
int? cachedMessageCount = queue.ApproximateMessageCount;
Console.WriteLine("Number of messages in queue: {0}", cachedMessageCount);
// Dequeue a batch of 21 messages (up to 32) and set visibility timeout to 5 minutes. Note we are dequeuing 21 messages because the earlier
// UpdateEnqueuedMessage method left a message on the queue hence we are retrieving that as well.
Console.WriteLine("9. Dequeue 21 messages, allowing 5 minutes for the clients to process.");
foreach (CloudQueueMessage msg in await queue.GetMessagesAsync(21, TimeSpan.FromMinutes(5), null, null))
{
Console.WriteLine("Processing & deleting message with content: {0}", msg.AsString);
// Process all messages in less than 5 minutes, deleting each message after processing.
await queue.DeleteMessageAsync(msg);
}
}
/// <summary>
/// Update an enqueued message and its visibility time. For workflow scenarios this could enable you to update
/// the status of a task as well as extend the visibility timeout in order to provide more time for a client
/// continue working on the message before another client can see the message.
/// </summary>
/// <param name="queue">The sample queue</param>
private static async Task UpdateEnqueuedMessageAsync(CloudQueue queue)
{
// Insert another test message into the queue
Console.WriteLine("5. Insert another test message ");
await queue.AddMessageAsync(new CloudQueueMessage("Hello World Again!"));
Console.WriteLine("6. Change the contents of a queued message");
CloudQueueMessage message = await queue.GetMessageAsync();
message.SetMessageContent("Updated contents.");
await queue.UpdateMessageAsync(
message,
TimeSpan.Zero, // For the purpose of the sample make the update visible immediately
MessageUpdateFields.Content |
MessageUpdateFields.Visibility);
}
/// <summary>
/// Demonstrate basic queue operations such as adding a message to a queue, peeking at the front of the queue and dequeing a message.
/// </summary>
/// <param name="queue">The sample queue</param>
private static async Task BasicQueueOperationsAsync(CloudQueue queue)
{
// Insert a message into the queue using the AddMessage method.
Console.WriteLine("2. Insert a single message into a queue");
await queue.AddMessageAsync(new CloudQueueMessage("Hello World!"));
// Peek at the message in the front of a queue without removing it from the queue using PeekMessage (PeekMessages lets you peek >1 message)
Console.WriteLine("3. Peek at the next message");
CloudQueueMessage peekedMessage = await queue.PeekMessageAsync();
if (peekedMessage != null)
{
Console.WriteLine("The peeked message is: {0}", peekedMessage.AsString);
}
// You de-queue a message in two steps. Call GetMessage at which point the message becomes invisible to any other code reading messages
// from this queue for a default period of 30 seconds. To finish removing the message from the queue, you call DeleteMessage.
// This two-step process ensures that if your code fails to process a message due to hardware or software failure, another instance
// of your code can get the same message and try again.
Console.WriteLine("4. De-queue the next message");
CloudQueueMessage message = await queue.GetMessageAsync();
if (message != null)
{
Console.WriteLine("Processing & deleting message with content: {0}", message.AsString);
await queue.DeleteMessageAsync(message);
}
}
public async Task CloudQueueAddMessageFullParameterAsync()
{
CloudQueueMessage futureMessage = new CloudQueueMessage("This message is for the future.");
CloudQueueMessage presentMessage = new CloudQueueMessage("This message is for the present.");
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateIfNotExistsAsync();
await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(2), null, null);
VerifyAddMessageResult(futureMessage);
// We should not be able to see the future message yet.
CloudQueueMessage retrievedMessage = await queue.GetMessageAsync();
Assert.IsNull(retrievedMessage);
await queue.AddMessageAsync(presentMessage, null, TimeSpan.Zero, null, null);
VerifyAddMessageResult(presentMessage);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromDays(1), null, null, null);
VerifyAddMessageResult(presentMessage);
// We should be able to see the present message.
retrievedMessage = await queue.GetMessageAsync();
Assert.IsNotNull(retrievedMessage);
Assert.AreEqual <string>(presentMessage.AsString, retrievedMessage.AsString);
await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(2), TimeSpan.FromDays(1), null, null);
VerifyAddMessageResult(futureMessage);
await queue.ClearAsync();
// -1 seconds should set an infinite ttl
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), null, null, null);
retrievedMessage = await queue.PeekMessageAsync();
Assert.AreEqual(DateTime.MaxValue.Year, retrievedMessage.ExpirationTime.Value.Year);
// There should be no upper bound on ttl
await queue.AddMessageAsync(presentMessage, TimeSpan.MaxValue, null, null, null);
// Check other edge cases
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(0), null, null);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(7 * 24 * 60 * 60), TimeSpan.FromSeconds(7 * 24 * 60 * 60 - 1), null, null);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), TimeSpan.FromSeconds(1), null, null);
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(1), TimeSpan.FromDays(2), null, null),
"Using a visibility timeout longer than the time to live should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(8), null, null),
"Using a visibility longer than the maximum visibility timeout should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromMinutes(-1), null, null),
"Using a negative visibility should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromMinutes(-1), null, null, null),
"Using a negative TTL other than -1 seconds (infinite) should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
() => queue.AddMessageAsync(futureMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), null, null),
"Visibility timeout must be strictly less than the TTL");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
() => queue.AddMessageAsync(presentMessage, null, CloudQueueMessage.MaxVisibilityTimeout, null, null),
"Null TTL will default to 7 days, which is the max visibility timeout. They cannot be equal.");
}
finally
{
queue.DeleteIfExistsAsync().Wait();
}
}
public async Task QueueRegionalSASTestAsync()
{
#if ASPNET_K
//CultureInfo currentCulture = CultureInfo.CurrentCulture;
//CultureInfo.CurrentCulture = new CultureInfo("it");
#else
string currentPrimaryLanguage = ApplicationLanguages.PrimaryLanguageOverride;
ApplicationLanguages.PrimaryLanguageOverride = "it";
#endif
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateAsync();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
// Prepare SAS authentication with full permissions
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
await queue.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
string sasTokenFromId = queue.GetSharedAccessSignature(null, id);
StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId);
CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId);
CloudQueueMessage receivedMessage1 = await sasQueueFromId.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage1.AsString);
string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
CloudQueueMessage receivedMessage2 = await sasQueueFromPolicy.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage2.AsString);
}
finally
{
#if ASPNET_K
//CultureInfo.CurrentCulture = currentCulture;
#else
ApplicationLanguages.PrimaryLanguageOverride = currentPrimaryLanguage;
#endif
queue.DeleteAsync().Wait();
}
}
public Task AddMessage(CloudQueue queue, string message)
{
return queue.AddMessageAsync(new CloudQueueMessage(message));
}
private static async Task ProcessBatchOfMessagesAsync(CloudQueue queue)
{
Console.WriteLine("7. Enqueue 20 messages.");
for (int i = 0; i < 20; i++)
{
await queue.AddMessageAsync(new CloudQueueMessage(string.Format("{0} - {1}", i, "Hello World")));
}
Console.WriteLine("8. Get the queue length");
queue.FetchAttributes();
int? cachedMessageCount = queue.ApproximateMessageCount;
Console.WriteLine("Number of messages in queue: {0}", cachedMessageCount);
Console.WriteLine("9. Dequeue 21 messages, allowing 5 minutes for the clients to process.");
foreach (CloudQueueMessage msg in await queue.GetMessagesAsync(21, TimeSpan.FromMinutes(5), null, null))
{
Console.WriteLine("Processing & deleting message with content: {0}", msg.AsString);
await queue.DeleteMessageAsync(msg);
}
}
private void QueuePage(Uri resourceUri, Uri itemType, int cantonCommitId, CloudQueue queue)
{
// mark that we sent a message for this
_workQueueStatus.AddOrUpdate(cantonCommitId, true, (k,v) => true);
JObject summary = new JObject();
summary.Add("uri", resourceUri.AbsoluteUri);
summary.Add("itemType", itemType.AbsoluteUri);
summary.Add("submitted", DateTime.UtcNow.ToString("O"));
summary.Add("failures", 0);
summary.Add("host", Host);
summary.Add("cantonCommitId", cantonCommitId);
_queueTasks.Enqueue(queue.AddMessageAsync(new CloudQueueMessage(summary.ToString())));
Log("Page Creation: Commit: " + cantonCommitId + " Uri: " + resourceUri.AbsoluteUri);
}
private static async Task AddMessageAndCreateIfNotExistsAsync(CloudQueue queue, CloudQueueMessage message, CancellationToken cancellationToken)
{
if (queue == null)
{
throw new ArgumentNullException("queue");
}
bool isQueueNotFoundException = false;
try
{
await queue.AddMessageAsync(message, cancellationToken);
return;
}
catch (StorageException exception)
{
if (!exception.IsNotFoundQueueNotFound())
{
throw;
}
isQueueNotFoundException = true;
}
Debug.Assert(isQueueNotFoundException);
await queue.CreateIfNotExistsAsync(cancellationToken);
await queue.AddMessageAsync(message, cancellationToken);
}
/// <summary>
///
/// </summary>
/// <param name="i"></param>
/// <param name="esLog"></param>
/// <param name="queue"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task SendQueueAsync(int i, ELSLogs esLog, CloudQueue queue, string message)
{
if (!_queueError)
//create, fufill and send message
{
await queue.AddMessageAsync(new CloudQueueMessage(message));
}
else
{
_cache.ListLeftPush("s", message);
}
}
public Task AddMessages(CloudQueue queue, IEnumerable<string> messages)
{
return Task.WhenAll(messages.Select(m => queue.AddMessageAsync(new CloudQueueMessage(m))));
}
private static async Task EnqueueCore(CloudQueue queue, DateTimeKey buildStateKey, BoundBuildId buildId, TimeSpan? delay, CancellationToken cancellationToken)
{
// Enqueue a message to process the build. Insert a delay if the build isn't finished yet so that
// we don't unnecessarily ask Jenkins for information.
var buildMessage = new BuildStateMessage()
{
BuildStateKeyRaw = buildStateKey.Key,
BuildNumber = buildId.Number,
HostRaw = buildId.Host.ToString(),
JobName = buildId.JobName
};
var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(buildMessage));
await queue.AddMessageAsync(
queueMessage,
timeToLive: null,
initialVisibilityDelay: delay,
options: null,
operationContext: null,
cancellationToken: cancellationToken);
}
private async Task SendQueueAsync(CloudQueue queue, string message, bool flag)
{
if (!flag)
//create, fufill and send message
{
await queue.AddMessageAsync(new CloudQueueMessage(message));
}
else
{
await _cache.ListLeftPushAsync("s", message);
}
}
public async Task UpdateQueueSASTestAsync()
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateAsync();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
SharedAccessQueuePolicy policy = new SharedAccessQueuePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages,
};
string id = Guid.NewGuid().ToString();
string sasToken = queue.GetSharedAccessSignature(policy, null);
StorageCredentials sasCreds = new StorageCredentials(sasToken);
CloudQueue sasQueue = new CloudQueue(queue.Uri, sasCreds);
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async () => await sasQueue.PeekMessageAsync(null, context),
context,
"Peek when Sas does not allow Read access on the queue",
HttpStatusCode.Forbidden);
await sasQueue.AddMessageAsync(message);
SharedAccessQueuePolicy policy2 = new SharedAccessQueuePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read,
};
string sasToken2 = queue.GetSharedAccessSignature(policy2, null);
sasCreds.UpdateSASToken(sasToken2);
sasQueue = new CloudQueue(queue.Uri, sasCreds);
await sasQueue.PeekMessageAsync();
}
finally
{
queue.DeleteIfExistsAsync().AsTask().Wait();
}
}