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