/// <summary> /// Updates a message /// </summary> /// <param name="messageText">Updated message</param> public void UpdateMessage(string messageText) { CloudQueueMessage message = _queue.GetMessage(); message.SetMessageContent(messageText); _queue.UpdateMessage(message, TimeSpan.FromSeconds(0.0), MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
public async Task RunAsync() { var routingSlip = new RoutingSlip <Order> { Steps = new List <Step> { new Step { Name = "new-order-step-a", Completed = false }, new Step { Name = "new-order-step-b", Completed = false }, new Step { Name = "new-order-step-c", Completed = false }, new Step { Name = "new-order-result", Completed = false }, }, Data = _order }; var storageAccount = CloudStorageAccount.Parse("UseDevelopmentStorage=true"); var client = storageAccount.CreateCloudQueueClient(); var queue = client.GetQueueReference(routingSlip.Steps[0].Name); await queue.CreateIfNotExistsAsync(); var message = new CloudQueueMessage(null); message.SetMessageContent(JsonConvert.SerializeObject(routingSlip)); await queue.AddMessageAsync(message); }
static void Main(string[] args) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("my-first-queue"); queue.CreateIfNotExists(); CloudQueueMessage message = queue.GetMessage(); message.SetMessageContent("Updated message..."); queue.UpdateMessage(message, TimeSpan.FromSeconds(0.0), MessageUpdateFields.Content | MessageUpdateFields.Visibility); CloudQueueMessage peekedMessage = queue.PeekMessage(); Console.WriteLine(peekedMessage.AsString); queue.FetchAttributes(); Console.WriteLine("Count of queues: ", queue.ApproximateMessageCount.ToString()); //queue.Delete(); Console.ReadKey(); }
public void CreateAccount() { _storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnection")); CloudQueueClient queueClient = _storageAccount.CreateCloudQueueClient(); CloudQueue cloudQueue = queueClient.GetQueueReference("tasks"); cloudQueue.CreateIfNotExists(); CloudQueueMessage message = new CloudQueueMessage("beep boop1"); // Customise time to live from 7 days default to 24 hours var timeSpan = new TimeSpan(24, 0, 0); cloudQueue.AddMessage(message, timeToLive: timeSpan); // Dequeue a message - also need to call delete for some reason - but Azure appears to delete on GetMessage anyway // CloudQueueMessage retrievedMessage = cloudQueue.GetMessage(); // Console.WriteLine($"Found message: {retrievedMessage.AsString}"); // cloudQueue.DeleteMessage(retrievedMessage); // Use peek to read from queue without dequeuing CloudQueueMessage peekedMessage = cloudQueue.PeekMessage(); Console.WriteLine($"Peeked message: {peekedMessage.AsString}"); // Update a message CloudQueueMessage updateMessage = cloudQueue.GetMessage(); Console.WriteLine($"Found message for update: {updateMessage.AsString}"); updateMessage.SetMessageContent("beep boop2"); cloudQueue.UpdateMessage(updateMessage, new TimeSpan(0, 0, 10), MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
public ActionResult UpdateMessage([Bind(Include = "message")] string message) { int total = 0; CloudQueueMessage getMessage = null; getMessage = queue.GetMessage(); if (getMessage != null) { getMessage.SetMessageContent(message); queue.UpdateMessage(getMessage, TimeSpan.FromSeconds(1), MessageUpdateFields.Content | MessageUpdateFields.Visibility); total = GetTotalOfMessage() ?? 0; return(View("Index", new Models.QueueSa() { TotalOfMessages = total, Message = string.Format("UPDATE: {0}", getMessage.AsString), Messages = queue.GetMessages(total == 0 ? 1 : total, new TimeSpan(1000)) })); } return(View("Index", new Models.QueueSa() { TotalOfMessages = total, Message = "UPDATE: There are no messages." })); }
public async Task AddMessageAsync(T message) { var msg = new CloudQueueMessage(string.Empty); msg.SetMessageContent(message.ToBinary()); await Queue.AddMessageAsync(msg); }
public async Task UpdateQueueMessage(string message) { CloudQueueMessage getMessage = await queue.GetMessageAsync(); getMessage.SetMessageContent(message); await queue.UpdateMessageAsync(getMessage, TimeSpan.FromSeconds(5), MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
public static async void updateDownloadCount(string templateName) { var message = new CloudQueueMessage(templateName); message.SetMessageContent(templateName); await(await getQueueReference()).AddMessageAsync(message); }
private CloudQueueMessage ToBinaryCloudQueueMessage(byte [] bytes) { var qMsg = new CloudQueueMessage(string.Empty); qMsg.SetMessageContent(bytes); return(qMsg); }
public async Task AbandonByErrorAsync(StorageQueueMessage message, TimeSpan?visibilityTimeout) { visibilityTimeout = visibilityTimeout ?? TimeSpan.Zero; var cloudQueueMessage = new CloudQueueMessage(message.QueueMessageId, message.PopReceipt); cloudQueueMessage.SetMessageContent(_serializer.Serialize(message.Properties)); await _queue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout.Value, MessageUpdateFields.Content | MessageUpdateFields.Visibility).ConfigureAwait(false); }
public Task SendAsync(WorkItem item, int delay, CancellationToken cancellationToken) { var message = new CloudQueueMessage(item.Id.ToString(), item.CorrelationId.ToString()); message.SetMessageContent(item.Payload); var timeToLive = item.ExpireOn - DateTime.UtcNow; return(_cloudQueue.AddMessageAsync(message, timeToLive, TimeSpan.FromSeconds(delay), null, null, cancellationToken)); }
private async Task RunAsync(CancellationToken cancellationToken) { // TODO: Replace the following with your own logic. // Retrieve storage account from connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the queue client CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a queue CloudQueue queue = queueClient.GetQueueReference("requestqueue"); // Peek at the next message //CloudQueueMessage peekedMessage = queue.PeekMessage(); while (!cancellationToken.IsCancellationRequested) { try { // Get the message from the queue and update the message contents. CloudQueueMessage message = queue.GetMessage(); if (queue.ApproximateMessageCount > 0) { message.SetMessageContent(message.Id); queue.UpdateMessage(message, TimeSpan.FromSeconds(60.0), // Make it invisible for another 60 seconds. MessageUpdateFields.Content | MessageUpdateFields.Visibility); // Display message. //Console.WriteLine(peekedMessage.AsString); Console.WriteLine("deleting message.."); queue.DeleteMessage(message); // Retrieve a reference to a container. CloudQueue queue2 = queueClient.GetQueueReference("responsequeue"); // Display message. // Create the queue if it doesn't already exist queue2.CreateIfNotExists(); // Create a message and add it to the queue. queue2.AddMessage(message); Console.WriteLine("message added successfully to response queue"); Trace.TraceInformation("Working"); await Task.Delay(1000); } } catch (Exception ex) { cancellationTokenSource.Cancel(); } } }
public async Task AddMessageAsync <T>(T message, TimeSpan?timeToLive = null, TimeSpan?initialVisibilityDelay = null, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken)) { var serializer = new Serializer(); var data = (byte[])null; using (var stream = new MemoryStream()) { serializer.Serialize(message, stream); data = stream.ToArray(); } // Check if the message exceeds the size allowed by Azure Storage queues if (data.Length > MAX_MESSAGE_CONTENT_SIZE) { // The message is too large. Therefore we must save the content to blob storage and // send a smaller message indicating where the actual message was saved // 1) Save the large message to blob storage var blobName = $"{DateTime.UtcNow.ToString("yyyy-MM-dd")}-{RandomGenerator.GenerateString(32)}"; var blob = _blobContainer.GetBlockBlobReference(blobName); await blob.UploadBytesAsync(data, null, cancellationToken).ConfigureAwait(false); // 2) Send a smaller message var largeEnvelope = new LargeMessageEnvelope { BlobName = blobName }; using (var stream = new MemoryStream()) { serializer.Serialize(largeEnvelope, stream); data = stream.ToArray(); } /* * Weird issue: the C# compiler throws "CS1503 Argument 1: cannot convert from 'byte[]' to 'string'" when initializing a new message with a byte array. * The work around is to initialize with an empty string and subsequently invoke the 'SetMessageContent' method with the byte array * var cloudMessage = new CloudQueueMessage(data); */ var cloudMessage = new CloudQueueMessage(string.Empty); cloudMessage.SetMessageContent(data); await _queue.AddMessageAsync(cloudMessage, timeToLive, initialVisibilityDelay, options, operationContext, cancellationToken).ConfigureAwait(false); } else { // The size of this message is within the range allowed by Azure Storage queues /* * Weird issue: the C# compiler throws "CS1503 Argument 1: cannot convert from 'byte[]' to 'string'" when initializing a new message with a byte array. * The work around is to initialize with an empty string and subsequently invoke the 'SetMessageContent' method with the byte array * var cloudMessage = new CloudQueueMessage(data); */ var cloudMessage = new CloudQueueMessage(string.Empty); cloudMessage.SetMessageContent(data); await _queue.AddMessageAsync(cloudMessage, timeToLive, initialVisibilityDelay, options, operationContext, cancellationToken).ConfigureAwait(false); } }
private static async Task <CloudQueueMessage> CreateQueueMessageAsync(CloudQueue cloudQueue, JObject json) { var queueMessage = new CloudQueueMessage(""); await cloudQueue.AddMessageAsync(queueMessage); json["initialid"] = queueMessage.Id; json["initialpopreceipt"] = queueMessage.PopReceipt; queueMessage.SetMessageContent(json.ToString(Newtonsoft.Json.Formatting.None)); return(queueMessage); }
public static void Run([QueueTrigger("resourcegroup-healthmonitor", Connection = "QueueStorageConnString")] string myQueueItem, TraceWriter log) { //GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ResourceHealth/availabilityStatuses?api-version=2015-01-01 log.Info($"C# Queue trigger function processed: {myQueueItem}"); var clientId = System.Environment.GetEnvironmentVariable("AADClientId", EnvironmentVariableTarget.Process); var secret = System.Environment.GetEnvironmentVariable("AADClientSecret", EnvironmentVariableTarget.Process); var tenantId = System.Environment.GetEnvironmentVariable("AADTenantId", EnvironmentVariableTarget.Process); var subscriptionId = System.Environment.GetEnvironmentVariable("SubscriptionId", EnvironmentVariableTarget.Process); var resourceGroupArray = myQueueItem.Split('/'); var resourceGroupName = resourceGroupArray[resourceGroupArray.Length - 1]; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(System.Environment.GetEnvironmentVariable("QueueStorageConnString", EnvironmentVariableTarget.Process)); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a queue. var queueName = "resource-healthmonitor"; CloudQueue queue = queueClient.GetQueueReference(queueName); // Create the queue if it doesn't already exist. queue.CreateIfNotExists(); var token = GetAccessToken(clientId, secret, tenantId, myQueueItem); if (token == null) { log.Error("Error getting access token."); } var resourcesHealth = GetResourceGroupHealth(myQueueItem, token, log); if (resourcesHealth == null) { log.Error("Error getting Resource Health for Resource Group: " + myQueueItem); } else if (resourcesHealth.Count == 0) { log.Warning("No resources found in Resource Group: " + myQueueItem); } else { foreach (AvailabilityStatus status in resourcesHealth) { if (status.properties.availabilityStateValue == AvailabilityStateValue.Unavailable || status.properties.availabilityStateValue == AvailabilityStateValue.Unknown) { //Sending the availability information to Storage Queues var jsonStr = JsonConvert.SerializeObject(status); string resourceHealthUri = "/providers/Microsoft.ResourceHealth/availabilityStatuses/current"; var resourceId = status.id.Substring(0, status.id.Length - resourceHealthUri.Length); CloudQueueMessage message = new CloudQueueMessage(resourceId, ""); message.SetMessageContent(jsonStr); queue.AddMessage(message); } } } }
/// <summary> /// update the contents and increase invisible time (default invisible time is 30 second after GetMessage) /// </summary> public static void UpdateMessage() { CloudQueue queue = GetQueue(); CloudQueueMessage messageX = queue.GetMessage(); messageX.SetMessageContent("Updated contents." + DateTime.Now.ToLongTimeString()); queue.UpdateMessage(messageX, TimeSpan.FromMinutes(1.0), // Make it invisible for another 60 seconds. MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
public static void Update(CloudQueue queue, string msg) { // Get the message from the queue and update the message contents. CloudQueueMessage message = queue.GetMessage(); message.SetMessageContent(msg); queue.UpdateMessage(message, TimeSpan.FromSeconds(60.0), // Make it visible for another 60 seconds. MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
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 CloudQueueMessage BuildCloudQueueMessage(TransportMessage message) { var jsonMsg = JObject.FromObject(message); var msgBytes = (Serializer.Serialize(jsonMsg) as MemoryStream).ToArray(); var queueMessage = new CloudQueueMessage(message.Id, ""); queueMessage.SetMessageContent(msgBytes); return(queueMessage); }
public async Task QueueMessageBatchAsync <T>(Guid streamGuid, String streamNamespace, IEnumerable <T> events, StreamSequenceToken token, Dictionary <string, object> requestContext) { if (events == null) { throw new ArgumentNullException("events", "Trying to QueueMessageBatchAsync null data."); } //int count = events.Count(); //if (count != 1) //{ // throw new OrleansException("Trying to QueueMessageBatchAsync a batch of more than one event. " + // "SimpleAzureQueueAdapter does not support batching. Instead, you can batch in your application code."); //} object data = events.First(); bool isBytes = data is byte[]; bool isString = data is string; if (data != null && !isBytes && !isString) { throw new OrleansException( string.Format( "Trying to QueueMessageBatchAsync a type {0} which is not a byte[] and not string. " + "SimpleAzureQueueAdapter only supports byte[] or string.", data.GetType())); } if (Queue == null) { var tmpQueue = new AzureQueueDataManager(QueueName, DataConnectionString); await tmpQueue.InitQueueAsync(); if (Queue == null) { Queue = tmpQueue; } } CloudQueueMessage cloudMsg = null; if (isBytes) { //new CloudQueueMessage(byte[]) not supported in netstandard cloudMsg = new CloudQueueMessage(null as string); cloudMsg.SetMessageContent(data as byte[]); } else if (isString) { cloudMsg = new CloudQueueMessage(data as string); } else if (data == null) { // It's OK to pass null data. why should I care? cloudMsg = new CloudQueueMessage(null as string); } await Queue.AddQueueMessage(cloudMsg); }
/// <summary> /// Creates a cloud queue message from stream event data. /// </summary> public CloudQueueMessage ToCloudQueueMessage <T>(Guid streamGuid, string streamNamespace, IEnumerable <T> events, Dictionary <string, object> requestContext) { var azureQueueBatchMessage = new AzureQueueBatchContainerV2(streamGuid, streamNamespace, events.Cast <object>().ToList(), requestContext); var rawBytes = this.serializationManager.SerializeToByteArray(azureQueueBatchMessage); //new CloudQueueMessage(byte[]) not supported in netstandard, taking a detour to set it var cloudQueueMessage = new CloudQueueMessage(null as string); cloudQueueMessage.SetMessageContent(rawBytes); return(cloudQueueMessage); }
/// <summary> /// Update the content of the first message with given byte content /// </summary> /// <param name="queueName"></param> /// <param name="content"></param> /// <returns></returns> public async Task UpdateMessage(string queueName, byte[] content) { // Retrieve a reference to a queue. CloudQueue queue = queueClient.GetQueueReference(queueName); // Get the message from the queue and update the message contents. CloudQueueMessage message = await queue.GetMessageAsync(); message.SetMessageContent(content); queue.UpdateMessage(message, TimeSpan.FromSeconds(0.0), // Make it visible immediately. MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
/// <summary> /// Update 1 queue /// </summary> /// <param name="cloudQueue">CloudQueue object</param> /// <returns>Task object</returns> private async Task Update1EnqueuedMessageAsync(CloudQueue cloudQueue) { Console.WriteLine("4. Change the contents of of the last queued message"); CloudQueueMessage cloudQueueMessage = await cloudQueue.GetMessageAsync(); cloudQueueMessage.SetMessageContent("Queue is update with new content."); await cloudQueue.UpdateMessageAsync( cloudQueueMessage, TimeSpan.FromSeconds(5), // Wait 5 seconds till the content is visible MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
private static void ChangeMessageConent() { // Get the message from the queue and update the message contents. CloudQueueMessage message = queue.GetMessage(); message.SetMessageContent("Updated contents."); queue.UpdateMessage(message, TimeSpan.FromSeconds(10.0), // Make it invisible for another 10 seconds. MessageUpdateFields.Content | MessageUpdateFields.Visibility); Console.WriteLine("ZZZZing for 10 seconds..."); Thread.Sleep(10000); // Sleep for 10 seconds. }
static CloudQueueMessage Serialize(TransportMessage message, string messageId, string popReceipt) { var cloudStorageQueueTransportMessage = new CloudStorageQueueTransportMessage { Headers = message.Headers, Body = message.Body }; var cloudQueueMessage = new CloudQueueMessage(messageId, popReceipt); cloudQueueMessage.SetMessageContent(JsonConvert.SerializeObject(cloudStorageQueueTransportMessage)); return(cloudQueueMessage); }
static CloudQueueMessage Serialize(string messageId, string popReceipt, Dictionary <string, string> headers, byte[] body) { var cloudStorageQueueTransportMessage = new CloudStorageQueueTransportMessage { Headers = headers, Body = body }; var cloudQueueMessage = new CloudQueueMessage(messageId, popReceipt); cloudQueueMessage.SetMessageContent(JsonConvert.SerializeObject(cloudStorageQueueTransportMessage)); return(cloudQueueMessage); }
public static async Task UpdateEnqueuedMessageAsync(CloudQueue queue, string Message) { await queue.AddMessageAsync(new CloudQueueMessage(Message)); CloudQueueMessage message = await queue.GetMessageAsync(); message.SetMessageContent(Message); await queue.UpdateMessageAsync( message, TimeSpan.Zero, // For the purpose of the sample make the update visible immediately MessageUpdateFields.Content | MessageUpdateFields.Visibility); }
private static async Task UpdateEnqueuedMessageAsync(CloudQueue queue) { await queue.AddMessageAsync(new CloudQueueMessage("Hello World Again!")); 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); }
static void Main(string[] args) { // Retrieve storage account from connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse(@"DefaultEndpointsProtocol=https;AccountName=arena11storage;AccountKey=jV1YbiOkX06nmDyNkyJvl5raNMeGa+URoQc+g7BaY5CAMv4gRWer5hwhgvjrI/8VhuSgCtZvRiTekjqFZWxv1Q==;EndpointSuffix=core.windows.net"); // Create the queue client. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a container. CloudQueue queue = queueClient.GetQueueReference("arenaqueue"); var msg = queue.GetMessage(new TimeSpan(0, 1, 0)); var messagenew = new CloudQueueMessage(msg.Id, msg.PopReceipt); messagenew.SetMessageContent("updatedddd by popreceiptid and id"); //msg.SetMessageContent("this is changed"); queue.UpdateMessage(messagenew, new TimeSpan(0, 1, 0) , MessageUpdateFields.Content | MessageUpdateFields.Visibility); //var msg = queue.PeekMessage(); //Console.WriteLine(msg.AsString); //Console.Read(); //var msg = queue.GetMessage(new TimeSpan(0, 1, 0)); //Console.WriteLine(msg.AsString); //Console.Read(); //foreach (var msg1 in queue.GetMessages(10)) //{ // queue.DeleteMessage(msg1); //} //Console.WriteLine(msg.AsString); //queue.DeleteMessage(msg); //// Create the queue if it doesn't already exist //queue.CreateIfNotExists(); //// Create a message and add it to the queue. //CloudQueueMessage message = new CloudQueueMessage("Hello, World"); //queue.AddMessage(message); //message = new CloudQueueMessage("Hello, World1"); //queue.AddMessage(message); }
public async Task UpdateMessageAsync(QueueMessage <T> queueMessage, TimeSpan visibilityTimeout) { var cloudQueueMessage = new CloudQueueMessage(queueMessage.Id, queueMessage.PopReceipt); string serializedContent = Serialize(queueMessage.Content); cloudQueueMessage.SetMessageContent(serializedContent); TimeSpan duration = await EventTimer.TimeAsync(async() => { await _cloudQueue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout, MessageUpdateFields.Content | MessageUpdateFields.Visibility); }); _eventSource.OnQueueMessageUpdated(duration); }