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