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(); } }