static void Main(string[] args)
{
var storageAccount = CloudStorageAccount.DevelopmentStorageAccount;
var queueClient = storageAccount.CreateCloudQueueClient();
var queue = queueClient.GetQueueReference("samples-asq-nativeintegration"); //"Samples.ASQ.NativeIntegration");
#region SerializedMessage
var nativeMessage = @"{""Content"":""Hello from native sender"",""SendOnUtc"":""2015-10-27T20:47:27.4682716Z""}";
var nativeMessageAsBytes = Encoding.UTF8.GetBytes(nativeMessage);
#endregion
#region NecessaryHeaders
var headers = new Dictionary<string, string>
{
{ "NServiceBus.EnclosedMessageTypes", "Shared.NativeMessage" },
{ "NServiceBus.MessageIntent", "Send" }
};
#endregion
// TODO: message body is byte
var message = new CloudQueueMessage(@"{""IdForCorrelation"":null,""Id"":""31949487-2b67-49e0-b961-96f7a834d877"",""MessageIntent"":1,""ReplyToAddress"":""native-sender"",""TimeToBeReceived"":""00:00:00"",""Headers"":{""NServiceBus.EnclosedMessageTypes"":""Shared.NativeMessage"",""NServiceBus.MessageIntent"":""Send""},""Body"":""eyJDb250ZW50IjoiSGVsbG8gZnJvbSBuYXRpdmUgc2VuZGVyIiwiU2VuZE9uVXRjIjoiMjAxNS0xMC0yOFQwNDowNDo0MC45MDg0NDI4WiJ9"",""CorrelationId"":null,""Recoverable"":false}");
queue.AddMessage(message);
Console.WriteLine("Native message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void Remove(CloudQueueMessage message)
{
if (message != null)
{
_queue.DeleteMessage(message);
}
}
protected override async Task ReleaseMessageAsync(CloudQueueMessage message, FunctionResult result, TimeSpan visibilityTimeout, CancellationToken cancellationToken)
{
//Use exponential backoff. Default implementation retries the operation way too quickly.
visibilityTimeout = TimeSpan.FromSeconds(Math.Pow(3, message.DequeueCount));
await base.ReleaseMessageAsync(message, result, visibilityTimeout, cancellationToken);
}
private void ProcessQueueMessage(CloudQueueMessage msg)
{
Trace.TraceInformation("Processing queue message {0}", msg);
// Queue message contains AdId.
var adId = int.Parse(msg.AsString);
Ad ad = db.Ads.Find(adId);
if (ad == null)
{
throw new Exception(String.Format("AdId {0} not found, can't create thumbnail", adId.ToString()));
}
CloudBlockBlob inputBlob = this.imagesBlobContainer.GetBlockBlobReference(ad.ImageURL);
string thumbnailName = Path.GetFileNameWithoutExtension(inputBlob.Name) + "thumb.jpg";
CloudBlockBlob outputBlob = this.imagesBlobContainer.GetBlockBlobReference(thumbnailName);
using (Stream input = inputBlob.OpenRead())
using (Stream output = outputBlob.OpenWrite())
{
ConvertImageToThumbnailJPG(input, output);
outputBlob.Properties.ContentType = "image/jpeg";
}
Trace.TraceInformation("Generated thumbnail in blob {0}", thumbnailName);
ad.ThumbnailURL = outputBlob.Uri.ToString();
db.SaveChanges();
Trace.TraceInformation("Updated thumbnail URL in database: {0}", ad.ThumbnailURL);
// Remove message from queue.
this.imagesQueue.DeleteMessage(msg);
}
public void CloudQueueCreateMessage()
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
queue.CreateIfNotExists();
CloudQueueMessage message = new CloudQueueMessage(Guid.NewGuid().ToString());
queue.AddMessage(message);
CloudQueueMessage retrMessage = queue.GetMessage();
string messageId = retrMessage.Id;
string popReceipt = retrMessage.PopReceipt;
// Recreate the message using the messageId and popReceipt.
CloudQueueMessage newMessage = new CloudQueueMessage(messageId, popReceipt);
Assert.AreEqual(messageId, newMessage.Id);
Assert.AreEqual(popReceipt, newMessage.PopReceipt);
queue.UpdateMessage(newMessage, TimeSpan.FromSeconds(30), MessageUpdateFields.Visibility);
CloudQueueMessage retrMessage2 = queue.GetMessage();
Assert.AreEqual(null, retrMessage2);
}
finally
{
queue.DeleteIfExists();
}
}
public Task DeleteMessage(CloudQueueMessage message, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginDeleteMessage(message, options, operationContext, null, null),
_inner.EndDeleteMessage,
cancellationToken);
}
public Task AddMessage(CloudQueueMessage message, TimeSpan? timeToLive = null, TimeSpan? initialVisibilityDelay = null, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken? cancellationToken = null)
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginAddMessage(message, timeToLive, initialVisibilityDelay, options, operationContext, null, null),
_inner.EndAddMessage,
cancellationToken);
}
public QueueMessage Dequeue(int? invisibilityTimeout = null)
{
while (true)
{
invisibilityTimeout = invisibilityTimeout ?? _timeout;
if (invisibilityTimeout.Value < 1)
{
invisibilityTimeout = 1;
}
this.CurrentMessage = Queue.GetMessage(new TimeSpan(0, 0, invisibilityTimeout.Value));
if (this.CurrentMessage != null)
{
if (this.CurrentMessage.DequeueCount >= _dequeLimit)
{
DashTrace.TraceWarning("Discarding message after exceeding deque limit of {0}. Message details: {1}",
this.CurrentMessage.DequeueCount,
this.CurrentMessage.AsString);
DeleteCurrentMessage();
}
else
{
return JsonConvert.DeserializeObject<QueueMessage>(this.CurrentMessage.AsString);
}
}
else
{
break;
}
}
return null;
}
public async Task PushToResizeQueue(BlobInformation blobInformation)
{
//var namespaceManager = NamespaceManager.CreateFromConnectionString(AppSettings.ServiceBusConnectionString);
//if (!namespaceManager.QueueExists(AppSettings.ResizeQueueName))
//{
// namespaceManager.CreateQueue(AppSettings.ResizeQueueName);
//}
//QueueClient Client = QueueClient.CreateFromConnectionString(AppSettings.ServiceBusConnectionString, AppSettings.ResizeQueueName);
//Client.Send(new BrokeredMessage(blobInformation));
try
{
CloudStorageAccount account;
string storageConnectionString = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", AppSettings.StorageAccountName, AppSettings.StorageAccountKey);
if (CloudStorageAccount.TryParse(storageConnectionString, out account))
{
CloudQueueClient queueClient = account.CreateCloudQueueClient();
CloudQueue resizeRequestQueue = queueClient.GetQueueReference(AppSettings.ResizeQueueName);
resizeRequestQueue.CreateIfNotExists();
var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(blobInformation));
await resizeRequestQueue.AddMessageAsync(queueMessage);
}
}
catch (Exception ex)
{
Trace.TraceError("Exception in QueueManager.PushToQueue => " + ex.Message);
}
}
public void PutRequestInQueue(ActionRequest request)
{
var queue = GetCloudQueue();
var message = new CloudQueueMessage(JsonConvert.SerializeObject(request));
queue.AddMessage(message);
}
/// <inheritdoc />
public async Task SendWebHookWorkItemsAsync(IEnumerable<WebHookWorkItem> workItems)
{
if (workItems == null)
{
throw new ArgumentNullException(nameof(workItems));
}
// Serialize WebHook requests and convert to queue messages
IEnumerable<CloudQueueMessage> messages = null;
try
{
messages = workItems.Select(item =>
{
string content = JsonConvert.SerializeObject(item, _serializerSettings);
CloudQueueMessage message = new CloudQueueMessage(content);
return message;
}).ToArray();
}
catch (Exception ex)
{
string msg = string.Format(CultureInfo.CurrentCulture, AzureStorageResources.AzureSender_SerializeFailure, ex.Message);
_logger.Error(msg, ex);
throw new InvalidOperationException(msg);
}
// Insert queue messages into queue.
CloudQueue queue = _manager.GetCloudQueue(_connectionString, WebHookQueue);
await _manager.AddMessagesAsync(queue, messages);
}
public void crawlingPhase(CloudQueueMessage urlMessage)
{
totalUrls++;
String url = urlMessage.AsString;
if (!alreadyVisitedUrls.Contains(url))
{
alreadyVisitedUrls.Add(url);
try
{
HtmlWeb hw = new HtmlWeb();
HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
doc = hw.Load(url);
String date = "";
if (doc.DocumentNode.SelectSingleNode("//head/meta[@property='og:pubdate']") != null)
{
String stringDate = doc.DocumentNode.SelectSingleNode("//head/meta[@property='og:pubdate']").GetAttributeValue("content", "default").Substring(0, 10);
date = DateTime.ParseExact(stringDate, "yyyy-MM-dd", CultureInfo.InvariantCulture).ToString("yyyy/MM/dd");
}
String fullTitle = doc.DocumentNode.SelectSingleNode("//head/title").InnerText;
String[] titles = fullTitle.Split(' ');
foreach (string partTitle in titles) {
if (!partTitle.Equals(" ") && !partTitle.Equals("-") && !partTitle.Equals("CNN.com") && !partTitle.Equals(""))
{
CrawlerEntry entry = new CrawlerEntry(url, fullTitle, date, partTitle);
TableOperation insertOperation = TableOperation.Insert(entry);
table.Execute(insertOperation);
tableSize++;
}
}
//get urls in page
foreach (HtmlNode link in doc.DocumentNode.SelectNodes("//a[@href]"))
{
string href = link.GetAttributeValue("href", string.Empty);
HashSet<String> links = new HashSet<String>();
String[] hrefSplit = href.Split('/');
String html = hrefSplit[hrefSplit.Length - 1];
//if the href is not in the disallowed urls, is not already crawled, is not a duplicate link, is a valid html page, and on cnn or bleacherreport
if (!disallowedUrls.Any(s => href.Contains(s)) && !alreadyVisitedUrls.Any(s => s.Equals(href)) && !links.Contains(href) && rgx.IsMatch(html) && (href.Contains("cnn.com") || href.Contains("bleacherreport.com")))
{
//store remaining into queue
urlQueue.AddMessage(new CloudQueueMessage(href));
//adds link to current link set
links.Add(href);
}
}
}
catch
{
}
}
updateTotalUrls();
//Update last 10 urls crawled
updateLastUrl(urlMessage.AsString);
urlQueue.DeleteMessage(urlMessage);
}
public void Publish(BusMessage busMessage)
{
byte[] _busMessage = busMessage.ToBinary();
CloudQueue queue = GetQueue();
CloudQueueMessage message = new CloudQueueMessage(_busMessage);
queue.AddMessage(message);
}
public async Task AddQuere(RImage img)
{
CloudQueue queue = QueueClient.GetQueueReference("myqueues");
await queue.CreateIfNotExistsAsync();
CloudQueueMessage message = new CloudQueueMessage(JsonConvert.SerializeObject(img));
await queue.AddMessageAsync(message);
}
public static void QueueActivity(
string userId,
EventType eventType,
string message)
{
try
{
var cloudStorageAccount =
CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
var queueReference =
cloudStorageAccount.CreateCloudQueueClient()
.GetQueueReference("activity");
queueReference.CreateIfNotExists();
var activity = new Activity
{
UserId = userId,
Event = eventType,
Date = DateTime.Now,
Message = message
};
var cloudQueueMessage =
new CloudQueueMessage(JsonConvert.SerializeObject(activity));
queueReference.AddMessage(cloudQueueMessage);
}
catch (Exception exception)
{
Trace.TraceError(exception.Message);
}
}
static void Main()
{
Console.WriteLine("*************************************************************************");
Console.WriteLine("WebJobUsageDaily:Main starting. DateTimeUTC: {0}", DateTime.UtcNow);
List<Subscription> abis = Commons.Utils.GetSubscriptions();
foreach (Subscription s in abis)
{
//Commons.Utils.UpdateSubscriptionStatus(s.Id, DataGenStatus.Pending, DateTime.UtcNow.AddYears(-3));
try
{
//DateTime sdt = DateTime.Now.AddYears(-3);
DateTime sdt = DateTime.Now.AddDays(-2);
DateTime edt = DateTime.Now;
BillingRequest br = new BillingRequest(s.Id, s.OrganizationId, sdt, edt);
// Insert into Azure Storage Queue
var storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ToString());
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue subscriptionsQueue = queueClient.GetQueueReference(ConfigurationManager.AppSettings["ida:QueueBillingDataRequests"].ToString());
subscriptionsQueue.CreateIfNotExists();
var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(br));
subscriptionsQueue.AddMessageAsync(queueMessage);
Console.WriteLine(String.Format("Sent id for daily billing log: {0}", s.Id));
Commons.Utils.UpdateSubscriptionStatus(s.Id, DataGenStatus.Pending, DateTime.UtcNow);
}
catch (Exception e)
{
Console.WriteLine("WebJobUsageDaily - SendQueue: " + e.Message);
}
} // foreach
}
// POST api/values
public void Post([FromBody]int value)
{
//the only admitted values are from 1 to 4
if(value>=1 && value <= 4)
{
// Retrieve storage account from connection string
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
Microsoft.Azure.CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Create the queue client.
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
// Retrieve a reference to a queue.
CloudQueue queue = queueClient.GetQueueReference("myqueue");
// Create the queue if it doesn't already exist.
queue.CreateIfNotExists();
// Create a message and add it to the queue.
CloudQueueMessage message = new CloudQueueMessage(value.ToString());
queue.AddMessage(message);
}
}
protected void SignButton_Click(object sender, EventArgs e)
{
if (this.FileUpload1.HasFile)
{
this.InitializeStorage();
// upload the image to blob storage
string uniqueBlobName = string.Format("guestbookpics/image_{0}{1}", Guid.NewGuid().ToString(), Path.GetExtension(this.FileUpload1.FileName));
CloudBlockBlob blob = blobStorage.GetContainerReference("guestbookpics").GetBlockBlobReference(uniqueBlobName);
blob.Properties.ContentType = this.FileUpload1.PostedFile.ContentType;
blob.UploadFromStream(this.FileUpload1.FileContent);
System.Diagnostics.Trace.TraceInformation("Uploaded image '{0}' to blob storage as '{1}'", this.FileUpload1.FileName, uniqueBlobName);
// create a new entry in table storage
GuestBookEntry entry = new GuestBookEntry() { GuestName = this.NameTextBox.Text, Message = this.MessageTextBox.Text, PhotoUrl = blob.Uri.ToString(), ThumbnailUrl = blob.Uri.ToString() };
GuestBookDataSource ds = new GuestBookDataSource();
ds.AddGuestBookEntry(entry);
System.Diagnostics.Trace.TraceInformation("Added entry {0}-{1} in table storage for guest '{2}'", entry.PartitionKey, entry.RowKey, entry.GuestName);
// queue a message to process the image
var queue = queueStorage.GetQueueReference("guestthumbs");
var message = new CloudQueueMessage(string.Format("{0},{1},{2}", uniqueBlobName, entry.PartitionKey, entry.RowKey));
queue.AddMessage(message);
System.Diagnostics.Trace.TraceInformation("Queued message to process blob '{0}'", uniqueBlobName);
}
this.NameTextBox.Text = string.Empty;
this.MessageTextBox.Text = string.Empty;
this.DataList1.DataBind();
}
private void InvokeQueueFunctionAndWaitForResult(MethodInfo function, CloudQueueMessage message = null)
{
if (message == null)
{
message = new CloudQueueMessage(POCO.JsonSample);
}
string queueName = CreateQueueName(function, input: true);
CloudQueueClient queueClient = StorageAccount.CloudStorageAccount.CreateCloudQueueClient();
CloudQueue queue = queueClient.GetQueueReference(queueName);
queue.CreateIfNotExists();
queue.AddMessage(message);
JobHostConfiguration hostConfiguration = new JobHostConfiguration(StorageAccount.ConnectionString)
{
TypeLocator = new ExplicitTypeLocator(
typeof(QueueArgumentsDisplayFunctions),
typeof(DoneNotificationFunction))
};
using (JobHost host = new JobHost(hostConfiguration))
using (DoneNotificationFunction._doneEvent = new ManualResetEvent(initialState: false))
{
host.Start();
DoneNotificationFunction._doneEvent.WaitOne();
host.Stop();
}
}
public QueueListenerTests()
{
CloudQueue queue = new CloudQueue(new Uri("https://test.queue.core.windows.net/testqueue"));
Mock<IStorageQueue> mockQueue = new Mock<IStorageQueue>(MockBehavior.Strict);
mockQueue.Setup(p => p.SdkObject).Returns(queue);
_mockTriggerExecutor = new Mock<ITriggerExecutor<IStorageQueueMessage>>(MockBehavior.Strict);
Mock<IDelayStrategy> mockDelayStrategy = new Mock<IDelayStrategy>(MockBehavior.Strict);
Mock<IBackgroundExceptionDispatcher> mockExceptionDispatcher = new Mock<IBackgroundExceptionDispatcher>(MockBehavior.Strict);
TextWriter log = new StringWriter();
Mock<IQueueProcessorFactory> mockQueueProcessorFactory = new Mock<IQueueProcessorFactory>(MockBehavior.Strict);
JobHostQueuesConfiguration queuesConfig = new JobHostQueuesConfiguration();
QueueProcessorFactoryContext context = new QueueProcessorFactoryContext(queue, log, queuesConfig);
_mockQueueProcessor = new Mock<QueueProcessor>(MockBehavior.Strict, context);
JobHostQueuesConfiguration queueConfig = new JobHostQueuesConfiguration
{
MaxDequeueCount = 5,
QueueProcessorFactory = mockQueueProcessorFactory.Object
};
mockQueueProcessorFactory.Setup(p => p.Create(It.IsAny<QueueProcessorFactoryContext>())).Returns(_mockQueueProcessor.Object);
_listener = new QueueListener(mockQueue.Object, null, _mockTriggerExecutor.Object, mockDelayStrategy.Object, mockExceptionDispatcher.Object, log, null, queueConfig);
CloudQueueMessage cloudMessage = new CloudQueueMessage("TestMessage");
_storageMessage = new StorageQueueMessage(cloudMessage);
}
public ActionResult Index(SendViewModel model)
{
if (ModelState.IsValid)
{
if (model.SendBy == 0)
HostingEnvironment.QueueBackgroundWorkItem(ct => MessageSender.SendAsync(model));
else if (model.SendBy == 1)
{
BackgroundJob.Enqueue(() => MessageSender.SendWithEvent(model));
}
else
{
//TODO send queue message to use WebJobs
var storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString);
var queueClient = storageAccount.CreateCloudQueueClient();
var queue = queueClient.GetQueueReference("pending-mail");
// Create the queue if it doesn't already exist
queue.CreateIfNotExists();
var message = new CloudQueueMessage(JsonConvert.SerializeObject(model));
queue.AddMessage(message);
}
return RedirectToAction("Pending");
}
return View(model);
}
/// <summary>
/// DeleteMessageAsync
/// </summary>
/// <param name="queue"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static async Task DeleteMessageAsync(this CloudQueue queue, CloudQueueMessage msg)
{
var retVal = queue.BeginDeleteMessage(msg, null, null, null, null);
IAsyncResult arRetVal = retVal as IAsyncResult;
await Task.Factory.FromAsync(arRetVal, (r) => { queue.EndAddMessage(r); });
}
public async Task AQ_Standalone_1()
{
queueName = "Test-1-".ToLower() + Guid.NewGuid();
AzureQueueDataManager manager = await GetTableManager(queueName);
Assert.AreEqual(0, await manager.GetApproximateMessageCount());
CloudQueueMessage inMessage = new CloudQueueMessage("Hello, World");
await manager.AddQueueMessage(inMessage);
//Nullable<int> count = manager.ApproximateMessageCount;
Assert.AreEqual(1, await manager.GetApproximateMessageCount());
CloudQueueMessage outMessage1 = await manager.PeekQueueMessage();
logger.Info("PeekQueueMessage 1: {0}", AzureStorageUtils.PrintCloudQueueMessage(outMessage1));
Assert.AreEqual(inMessage.AsString, outMessage1.AsString);
CloudQueueMessage outMessage2 = await manager.PeekQueueMessage();
logger.Info("PeekQueueMessage 2: {0}", AzureStorageUtils.PrintCloudQueueMessage(outMessage2));
Assert.AreEqual(inMessage.AsString, outMessage2.AsString);
CloudQueueMessage outMessage3 = await manager.GetQueueMessage();
logger.Info("GetQueueMessage 3: {0}", AzureStorageUtils.PrintCloudQueueMessage(outMessage3));
Assert.AreEqual(inMessage.AsString, outMessage3.AsString);
Assert.AreEqual(1, await manager.GetApproximateMessageCount());
CloudQueueMessage outMessage4 = await manager.GetQueueMessage();
Assert.IsNull(outMessage4);
Assert.AreEqual(1, await manager.GetApproximateMessageCount());
await manager.DeleteQueueMessage(outMessage3);
Assert.AreEqual(0, await manager.GetApproximateMessageCount());
}
public void AddCall(Call call)
{
var serializer = new JavaScriptSerializer();
var content = serializer.Serialize(call);
var message = new CloudQueueMessage(content);
queue.AddMessage(message);
}
public static CloudQueueMessage CreateCloudQueueMessageFromByteArray([ReadOnlyArray] byte[] content)
#endif
{
CloudQueueMessage message = new CloudQueueMessage(null);
message.SetMessageContent(content);
return message;
}
public static string StartCrawling()
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable pageTable = tableClient.GetTableReference("indexedpages");
while (pageTable.Exists())
{
System.Threading.Thread.Sleep(1000);
}
pageTable.CreateIfNotExists();
Debug.WriteLine("Now in StartCrawling");
CloudQueue cmdQ = queueClient.GetQueueReference("cmdq");
cmdQ.CreateIfNotExists();
CloudQueue urlQ = queueClient.GetQueueReference("pagequeue");
urlQ.CreateIfNotExists();
urlQ.Clear();
urlQ.AddMessage(new CloudQueueMessage("http://www.cnn.com/robots.txt"));
Debug.WriteLine("THIS IS THE MESSAGE ADDED: " + urlQ.PeekMessage().AsString);
cmdQ.Clear();
string message = "start";
CloudQueueMessage cmd = new CloudQueueMessage(message);
cmdQ.AddMessage(cmd);
return message;
}
public async Task CloudQueueCreateMessageAsync()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(TestHelper.GenerateNewQueueName());
try
{
await queue.CreateIfNotExistsAsync();
CloudQueueMessage message = new CloudQueueMessage(Guid.NewGuid().ToString());
await queue.AddMessageAsync(message);
CloudQueueMessage retrMessage = await queue.GetMessageAsync();
string messageId = retrMessage.Id;
string popReceipt = retrMessage.PopReceipt;
// Recreate the message using the messageId and popReceipt.
CloudQueueMessage newMessage = new CloudQueueMessage(messageId, popReceipt);
Assert.AreEqual(messageId, newMessage.Id);
Assert.AreEqual(popReceipt, newMessage.PopReceipt);
await queue.UpdateMessageAsync(newMessage, TimeSpan.FromSeconds(30), MessageUpdateFields.Visibility);
CloudQueueMessage retrMessage2 = await queue.GetMessageAsync();
Assert.AreEqual(null, retrMessage2);
}
finally
{
queue.DeleteIfExistsAsync().AsTask().Wait();
}
}
protected override void processQueueMessage(CloudQueueMessage message)
{
base.processQueueMessage(message);
var rawData = message.AsBytes;
var stream = new MemoryStream(rawData);
stream.Seek(0, SeekOrigin.Begin);
var bFrmt = new BinaryFormatter();
var resObject = bFrmt.Deserialize(stream);
if (resObject is CloudQueueBlobMessage)
{
var cqbm = resObject as CloudQueueBlobMessage;
var msgContentRef = container.GetBlockBlobReference(cqbm.BlobName);
var msRes = new MemoryStream();
msgContentRef.DownloadToStream(msRes);
msRes.Seek(0, SeekOrigin.Begin);
resObject = bFrmt.Deserialize(msRes);
}
processMessage(resObject);
}
/// <inheritdoc />
public async Task SendWebHookWorkItemsAsync(IEnumerable<WebHookWorkItem> workItems)
{
if (workItems == null)
{
throw new ArgumentNullException("workItems");
}
CloudQueue queue = _manager.GetCloudQueue(_connectionString, WebHookQueue);
try
{
IEnumerable<Task> addTasks = workItems.Select(item =>
{
string content = JsonConvert.SerializeObject(item, _serializerSettings);
CloudQueueMessage message = new CloudQueueMessage(content);
return queue.AddMessageAsync(message);
});
await Task.WhenAll(addTasks);
}
catch (Exception ex)
{
string error = _manager.GetStorageErrorMessage(ex);
string msg = string.Format(CultureInfo.CurrentCulture, AzureStorageResources.AzureSender_AddFailure, error);
_logger.Error(msg, ex);
}
}
public Guid SubmitActionInQueue(string resourceId, ProvisioningLibrary.ResourceAction action, uint? duration = null)
{
var storageConnectionString = _settings["Provisioning:StorageConnectionString"];
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
var queueClient = storageAccount.CreateCloudQueueClient();
var queue = queueClient.GetQueueReference("processorqueue");
queue.CreateIfNotExists();
var actionId = Guid.NewGuid();
var actionMessage = new QueueMessage()
{
OperationGuid = actionId,
Action = action,
ResourceId = resourceId
};
queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(actionMessage)));
// if the action was to start a resource, but a duration was specified
// send a second queue message with initial visility time out set to
// 'duration' hours in the future. To trigger automatic stop
if (action == ResourceAction.Start && duration != null)
{
actionMessage.Action = ResourceAction.Stop;
CloudQueueMessage tmpMsg = new CloudQueueMessage(JsonConvert.SerializeObject(actionMessage));
queue.AddMessage(tmpMsg, null, new TimeSpan(0, (int)duration, 0),null,null);
}
return actionId;
}
private static void CopyMessage(CloudQueueMessage message, QueueMessage protocolMessage)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> AddMessageImpl(CloudQueueMessage message, TimeSpan?timeToLive, TimeSpan?initialVisibilityDelay, QueueRequestOptions options)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task DeleteMessageAsync(CloudQueueMessage message)
{
throw new System.NotImplementedException();
}
public virtual Task DeleteMessageAsync(CloudQueueMessage message, QueueRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
throw new System.NotImplementedException();
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public void CloudQueueMessageEncryptionWithStrictMode()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
// Create the resolver to be used for unwrapping.
DictionaryKeyResolver resolver = new DictionaryKeyResolver();
resolver.Add(aesKey);
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
string messageStr = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageStr);
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
// Add message with policy.
QueueRequestOptions createOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
createOptions.RequireEncryption = true;
queue.AddMessage(message, null, null, createOptions, null);
// Set policy to null and add message while RequireEncryption flag is still set to true. This should throw.
createOptions.EncryptionPolicy = null;
TestHelper.ExpectedException <InvalidOperationException>(
() => queue.AddMessage(message, null, null, createOptions, null),
"Not specifying a policy when RequireEnryption is set to true should throw.");
// Retrieve message
QueueEncryptionPolicy retrPolicy = new QueueEncryptionPolicy(null, resolver);
QueueRequestOptions retrieveOptions = new QueueRequestOptions()
{
EncryptionPolicy = retrPolicy
};
retrieveOptions.RequireEncryption = true;
CloudQueueMessage retrMessage = queue.GetMessage(null, retrieveOptions, null);
// Update message with plain text.
string updatedMessage = Guid.NewGuid().ToString("N");
retrMessage.SetMessageContent(updatedMessage);
queue.UpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
// Retrieve updated message with RequireEncryption flag but no metadata on the service. This should throw.
TestHelper.ExpectedException <StorageException>(
() => queue.GetMessage(null, retrieveOptions, null),
"Retrieving with RequireEncryption set to true and no metadata on the service should fail.");
// Set RequireEncryption to false and retrieve.
retrieveOptions.RequireEncryption = false;
queue.GetMessage(null, retrieveOptions, null);
}
finally
{
queue.DeleteIfExists();
}
}
public virtual Task AddMessageAsync(CloudQueueMessage message, TimeSpan?timeToLive, TimeSpan?initialVisibilityDelay, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
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 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();
}
}
