public void QueueNewTrackedSite(SiteRecordTableEntity siteRecord) { var queue = _queueClient.GetQueueReference(SiteMonitRConfiguration.QUEUE_NAME_NEW_SITE); queue.CreateIfNotExists(); queue.AddMessage(new CloudQueueMessage(siteRecord.Uri)); }
public override void Run() { // This is a sample worker implementation. Replace with your logic. Trace.TraceInformation("QueueProcessor_WorkerRole entry point called", "Information"); // Initialize the account information var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); // retrieve a reference to the messages queue var queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetProcessSasForQueues())); var queue = queueClient.GetQueueReference("messagequeue"); while (true) { Thread.Sleep(10000); Trace.TraceInformation("Working", "Information"); if (queue.Exists()) { if (DateTime.UtcNow.AddMinutes(1) >= this.serviceQueueSasExpiryTime) { queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetProcessSasForQueues())); queue = queueClient.GetQueueReference("messagequeue"); } var msg = queue.GetMessage(); if (msg != null) { Trace.TraceInformation(string.Format("Message '{0}' processed.", msg.AsString)); queue.DeleteMessage(msg); } } } }
public override void Run() { Trace.TraceInformation("QueueProcessor_WorkerRole entry point called", "Information"); var queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetQueueSas())); var queue = queueClient.GetQueueReference("messagequeue"); while (true) { Thread.Sleep(10000); Trace.TraceInformation("Working", "Information"); if (DateTime.UtcNow.AddMinutes(1) >= this.serviceQueueSasExpiryTime) { queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetQueueSas())); queue = queueClient.GetQueueReference("messagequeue"); } var msg = queue.GetMessage(); if (msg != null) { Trace.TraceInformation(string.Format("Message '{0}' processed.", msg.AsString)); queue.DeleteMessage(msg); } } }
public AzureQueueController() { var credentials = new StorageCredentials(ConfigurationManager.AppSettings["AzureAccountName"], ConfigurationManager.AppSettings["AzureKeyValue"]); var azureTableUri = new Uri("https://" + ConfigurationManager.AppSettings["AzureAccountName"] + ".queue.core.windows.net"); var client = new CloudQueueClient(azureTableUri, credentials); _queue = client.GetQueueReference(QueueName); }
public void Setup() { client = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudQueueClient(); client.ServerTimeout = TimeSpan.FromSeconds(10); nativeQueue = client.GetQueueReference(QueueName); nativeQueue.CreateIfNotExists(); nativeQueue.Clear(); sender = new AzureMessageQueueSender { Client = client, MessageSerializer = new JsonMessageSerializer(new MessageMapper()) }; sender.Init(QueueName, true); receiver = new AzureMessageQueueReceiver { Client = client, MessageSerializer = new JsonMessageSerializer(new MessageMapper()), }; receiver.Init(QueueName, true); }
private void CreateShipQueue(CloudQueueClient queueClient) { var shipQueueName = CloudConfigurationManager.GetSetting("ShipQueue.Name"); var queue = queueClient.GetQueueReference(shipQueueName); queue.CreateIfNotExists(); }
public QueueHelper(string storageAccountConnectionString) : base(storageAccountConnectionString) { queueClient = base.StorageAccount.CreateCloudQueueClient(); subscribeQueue = queueClient.GetQueueReference(ConfigurationManager.AppSettings["QueueAzuremailsubscribequeue"]); subscribeQueue.CreateIfNotExists(); }
public QueueHelper(string connection, string queueName) { var account = CloudStorageAccount.Parse(connection); var retry = new LinearRetry(TimeSpan.FromSeconds(1), 3); queueClient = account.CreateCloudQueueClient(); queueClient.RetryPolicy = retry; queue = queueClient.GetQueueReference(queueName); queue.CreateIfNotExists(); }
public CallQueueService(string storageConnectionStringConfigName = "StorageConnectionString") { var connectionString = CloudConfigurationManager.GetSetting(storageConnectionStringConfigName); var storageAccount = CloudStorageAccount.Parse(connectionString); this.queueClient = storageAccount.CreateCloudQueueClient(); this.queue = queueClient.GetQueueReference("calls"); this.queue.CreateIfNotExists(); }
protected virtual CloudQueue createQueue(CloudQueueClient client, string queueName) { // Retrieve a reference to a queues var queue = client.GetQueueReference(queueName); // Create the queue if it doesn't already exist queue.CreateIfNotExists(); return queue; }
public override void Run() { // This is a sample worker implementation. Replace with your logic. Trace.TraceInformation("QueueProcessor_WorkerRole entry point called", "Information"); // Initialize the account information var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); // retrieve a reference to the messages queue var queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetProcessSasForQueues())); var queue = queueClient.GetQueueReference("messagequeue"); while (true) { Thread.Sleep(10000); Trace.TraceInformation("Working", "Information"); if (queue.Exists()) { if (DateTime.UtcNow.AddMinutes(1) >= this.serviceQueueSasExpiryTime) { queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetProcessSasForQueues())); queue = queueClient.GetQueueReference("messagequeue"); } var msg = queue.GetMessage(); if (msg != null) { queue.FetchAttributes(); var messageParts = msg.AsString.Split(new char[] { ',' }); var message = messageParts[0]; var blobReference = messageParts[1]; if (queue.Metadata.ContainsKey("Resize") && string.Equals(message, "Photo Uploaded")) { var maxSize = queue.Metadata["Resize"]; Trace.TraceInformation("Resize is configured"); CloudBlockBlob outputBlob = this.container.GetBlockBlobReference(blobReference); outputBlob.FetchAttributes(); Trace.TraceInformation(string.Format("Image ContentType: {0}", outputBlob.Properties.ContentType)); Trace.TraceInformation(string.Format("Image width: {0}", outputBlob.Metadata["Width"])); Trace.TraceInformation(string.Format("Image hieght: {0}", outputBlob.Metadata["Height"])); } Trace.TraceInformation(string.Format("Message '{0}' processed.", msg.AsString)); queue.DeleteMessage(msg); } } } }
public PickCreator() { _storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); _queueClient = _storageAccount.CreateCloudQueueClient(); _queue = _queueClient.GetQueueReference("scaleoutsamplequeue"); _queue.CreateIfNotExists(); }
public AzureQueueHelper() { // Retrieve the storage account from a connection string in the web.config file. storageAccount = CloudStorageAccount.Parse( ConfigurationManager.AppSettings["AzureQueueConnectionString"]); // Create the cloud queue client. queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to our queue. queue = queueClient.GetQueueReference("receiptgenerator"); }
public override bool OnStart() { _account = CloudStorageAccount.Parse( RoleEnvironment.GetConfigurationSettingValue("SiteMonitRConnectionString") ); _queueClient = _account.CreateCloudQueueClient(); _queue = _queueClient.GetQueueReference(new WebSiteQueueConfiguration().GetIncomingQueueName()); _queue.CreateIfNotExists(); return base.OnStart(); }
protected AzureStorageQueueEndpointManager(AzureStorageQueueEndpoint endpoint, IAzureStorageConfiguration storageConfiguration) { if (storageConfiguration == null) throw new ArgumentNullException("storageConfiguration"); endpoint.Validate(); storageConfiguration.Validate(); CloudStorageAccount = CloudStorageAccount.Parse(storageConfiguration.ConnectionString); CloudQueueClient = CloudStorageAccount.CreateCloudQueueClient(); CloudQueue = CloudQueueClient.GetQueueReference(endpoint.QueueName); }
/// <summary> /// Wrapper method that adds a message to the queue. Accepts all the same parameters that /// CloudQueue.AddMessage accepts and passes them through. /// /// Gets a message from the queue using the default request options. This operation marks /// the retrieved message as invisible in the queue for the default visibility timeout period. /// </summary> /// <param name="visibilityTimeout">The visibility timeout interval.</param> /// <param name="options">A <see cref="T:Microsoft.WindowsAzure.Storage.Queue.QueueRequestOptions"/> object /// that specifies any additional options for the request. Specifying null will use the default request /// options from the associated service client (<see cref="T:Microsoft.WindowsAzure.Storage.Queue.CloudQueueClient"/>).</param> /// <param name="operationContext">An <see cref="T:Microsoft.WindowsAzure.Storage.OperationContext"/> object that represents /// the context for the current operation. This object is used to track requests to the storage service, and to provide /// additional runtime information about the operation.</param> /// <returns> /// A message. /// </returns> public CloudQueueMessage GetMessage(TimeSpan? visibilityTimeout = null, QueueRequestOptions options = null, OperationContext operationContext = null) { try { var cloudQueueClient = new CloudQueueClient(BaseUri, StorageCredentials); var cloudQueue = cloudQueueClient.GetQueueReference(QueueName); return cloudQueue.GetMessage(visibilityTimeout, options, operationContext); } catch (StorageException ex) { System.Diagnostics.Trace.TraceError("Exception thrown: " + ex); // TODO: exception handling, dude throw; } }
public void DeleteMessage(CloudQueueMessage message, QueueRequestOptions options = null, OperationContext operationContext = null) { try { var cloudQueueClient = new CloudQueueClient(BaseUri, StorageCredentials); var cloudQueue = cloudQueueClient.GetQueueReference(QueueName); cloudQueue.DeleteMessage(message, options, operationContext); } catch (StorageException ex) { System.Diagnostics.Trace.TraceError("Exception thrown: " + ex); // TODO: exception handling, dude throw; } }
public LeaseExpirationTests() { RandomNameResolver nameResolver = new RandomNameResolver(); _config = new JobHostConfiguration() { NameResolver = nameResolver, TypeLocator = new FakeTypeLocator(typeof(LeaseExpirationTests)) }; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_config.StorageConnectionString); _queueClient = storageAccount.CreateCloudQueueClient(); _queue = _queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName)); _queue.CreateIfNotExists(); }
public WindowsAzureQueueSiteResultReceiver(IStorageQueueConfiguration configuration) { _configuration = configuration; var connectionString = _configuration.GetConnectionString(); var queueToReceiveFrom = _configuration.GetIncomingQueueName(); _client = CloudStorageAccount.Parse(connectionString).CreateCloudQueueClient(); if (!string.IsNullOrEmpty(queueToReceiveFrom)) { _incomingQueue = _client.GetQueueReference(queueToReceiveFrom); _incomingQueue.CreateIfNotExists(); } }
public override void Run() { Trace.TraceInformation("QueueProcessor_WorkerRole entry point called", "Information"); var queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetQueueSas())); var queue = queueClient.GetQueueReference("messagequeue"); while (true) { Thread.Sleep(10000); Trace.TraceInformation("Working", "Information"); if (DateTime.UtcNow.AddMinutes(1) >= this.serviceQueueSasExpiryTime) { queueClient = new CloudQueueClient(this.uri, new StorageCredentials(this.GetQueueSas())); queue = queueClient.GetQueueReference("messagequeue"); } var msg = queue.GetMessage(); if (msg != null) { queue.FetchAttributes(); var messageParts = msg.AsString.Split(new char[] { ',' }); var message = messageParts[0]; var blobReference = messageParts[1]; if (queue.Metadata.ContainsKey("Resize") && string.Equals(message, "Photo Uploaded")) { var maxSize = queue.Metadata["Resize"]; Trace.TraceInformation("Resize is configured"); CloudBlockBlob outputBlob = this.container.GetBlockBlobReference(blobReference); outputBlob.FetchAttributes(); Trace.TraceInformation(string.Format("Image ContentType: {0}", outputBlob.Properties.ContentType)); Trace.TraceInformation(string.Format("Image width: {0}", outputBlob.Metadata["Width"])); Trace.TraceInformation(string.Format("Image hieght: {0}", outputBlob.Metadata["Height"])); } Trace.TraceInformation(string.Format("Message '{0}' processed.", message)); queue.DeleteMessage(msg); } } }
public Microsoft.WindowsAzure.Storage.Queue.CloudQueue GetStorageQueue(string name) { Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse( StorageConnectionString); ServicePoint tableServicePoint = ServicePointManager.FindServicePoint(storageAccount.TableEndpoint); tableServicePoint.UseNagleAlgorithm = false; Microsoft.WindowsAzure.Storage.Queue.CloudQueueClient client = storageAccount.CreateCloudQueueClient(); CloudQueue queue = client.GetQueueReference(name); queue.CreateIfNotExistsAsync().Wait(); return(queue); }
private void CreateMissingQueues(CloudQueueClient cloudQueueClient) { var shards = cloudQueueClient.ListQueues() .Where(q => q.Name.StartsWith(queueName, StringComparison.InvariantCulture)) .Select(q => q.Name); var queueNames = Enumerable.Range(0, queueCount) .Select(i => queueName + i) .Where(n => !shards.Contains(n)) .ToList(); foreach (var name in queueNames) { var q = cloudQueueClient.GetQueueReference(name); q.CreateIfNotExists(); } }
public void Initialise(string queueName) { if (string.IsNullOrEmpty(queueName)) { throw new ArgumentException("QueueName cannot be null or empty", "queueName"); } string connStr = ConfigManager.ConfigManager.GetConfigurationSetting(ConfigManager.ConfigManager.DefaultQueueStorageConnString, string.Empty); _storageAccount = CloudStorageAccount.Parse(connStr); _queueStorage = _storageAccount.CreateCloudQueueClient(); _queue = _queueStorage.GetQueueReference(queueName); _queue.CreateIfNotExists(); }
public void MaxDegreeOfParallelism_Queues(int batchSize, int maxExpectedParallelism) { _receivedMessages = 0; _currentSimultaneouslyRunningFunctions = 0; _maxSimultaneouslyRunningFunctions = 0; _numberOfQueueMessages = batchSize * 3; RandomNameResolver nameResolver = new RandomNameResolver(); JobHostConfiguration hostConfiguration = new JobHostConfiguration() { NameResolver = nameResolver, TypeLocator = new FakeTypeLocator(typeof(ParallelExecutionTests)), }; hostConfiguration.Queues.BatchSize = batchSize; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(hostConfiguration.StorageConnectionString); _queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = _queueClient.GetQueueReference(nameResolver.ResolveInString(TestQueueName)); queue.CreateIfNotExists(); for (int i = 0; i < _numberOfQueueMessages; i++) { int sleepTimeInSeconds = i % 2 == 0 ? 5 : 1; queue.AddMessage(new CloudQueueMessage(sleepTimeInSeconds.ToString())); } using (_allMessagesProcessed = new ManualResetEvent(initialState: false)) using (JobHost host = new JobHost(hostConfiguration)) { host.Start(); _allMessagesProcessed.WaitOne(TimeSpan.FromSeconds(90)); host.Stop(); } Assert.Equal(_numberOfQueueMessages, _receivedMessages); Assert.Equal(0, _currentSimultaneouslyRunningFunctions); // the actual value will vary sometimes based on the speed of the machine // running the test. int delta = _maxSimultaneouslyRunningFunctions - maxExpectedParallelism; Assert.True(delta == 0 || delta == 1); }
public async Task CloudQueuePeekMessageAsync() { CloudQueueClient client = GenerateCloudQueueClient(); string name = GenerateNewQueueName(); CloudQueue queue = client.GetQueueReference(name); await queue.CreateAsync(); CloudQueueMessage emptyMessage = await queue.PeekMessageAsync(); Assert.IsNull(emptyMessage); string msgContent = Guid.NewGuid().ToString("N"); CloudQueueMessage message = new CloudQueueMessage(msgContent); await queue.AddMessageAsync(message); CloudQueueMessage receivedMessage1 = await queue.PeekMessageAsync(); Assert.IsTrue(receivedMessage1.AsString == message.AsString); await queue.DeleteAsync(); }
public void CloudQueueClientListQueuesBasic() { string prefix = "dotnetqueuetest" + Guid.NewGuid().ToString("N"); List <string> queueNames = new List <string>(); int count = 30; for (int i = 0; i < count; i++) { queueNames.Add(prefix + i); } CloudQueueClient client = GenerateCloudQueueClient(); List <CloudQueue> emptyResults = client.ListQueues(prefix, QueueListingDetails.All, null, null).ToList(); Assert.AreEqual <int>(0, emptyResults.Count); foreach (string name in queueNames) { client.GetQueueReference(name).Create(); } List <CloudQueue> results = client.ListQueues(prefix, QueueListingDetails.All, null, null).ToList(); Assert.AreEqual <int>(results.Count, queueNames.Count); foreach (CloudQueue queue in results) { if (queueNames.Remove(queue.Name)) { queue.Delete(); } else { Assert.Fail(); } } Assert.AreEqual <int>(0, queueNames.Count); }
public async Task CloudQueueClientListQueuesBasicAsync() { DelegatingHandlerImpl delegatingHandlerImpl = new DelegatingHandlerImpl(new DelegatingHandlerImpl()); CloudQueueClient client = GenerateCloudQueueClient(delegatingHandlerImpl); string prefix = GenerateNewQueueName(); List <string> queueNames = new List <string>(); int count = 30; for (int i = 0; i < count; i++) { queueNames.Add(prefix + i); } QueueResultSegment emptyResults = await client.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null, null); Assert.AreEqual <int>(0, emptyResults.Results.Count()); foreach (string name in queueNames) { await client.GetQueueReference(name).CreateAsync(); } QueueResultSegment results = await client.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null, null); foreach (CloudQueue queue in results.Results) { if (queueNames.Remove(queue.Name)) { await queue.DeleteAsync(); } else { Assert.Fail(); } } Assert.AreEqual <int>(count, results.Results.Count()); Assert.AreNotEqual(0, delegatingHandlerImpl.CallCount); }
public void CloudQueueAddUpdateEncryptedEncodedMessage() { // Create the Key to be used for wrapping. SymmetricKey aesKey = new SymmetricKey("symencryptionkey"); CloudQueueClient client = GenerateCloudQueueClient(); string name = GenerateNewQueueName(); CloudQueue queue = client.GetQueueReference(name); try { queue.CreateIfNotExists(); byte[] messageBytes = new byte[100]; Random rand = new Random(); rand.NextBytes(messageBytes); string inputMessage = Convert.ToBase64String(messageBytes); CloudQueueMessage message = new CloudQueueMessage(inputMessage); queue.EncodeMessage = false; QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null); QueueRequestOptions options = new QueueRequestOptions() { EncryptionPolicy = policy }; // Add message queue.AddMessage(message, null, null, options, null); // Retrieve message CloudQueueMessage retrMessage = queue.GetMessage(null, options, null); Assert.AreEqual(inputMessage, retrMessage.AsString); } finally { queue.DeleteIfExists(); } }
public CloudContext(Cache cacheService) { _storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString); _tableClient = _storageAccount.CreateCloudTableClient(); _tableClient.DefaultRequestOptions.RetryPolicy = new ExponentialRetry(TimeSpan.FromMilliseconds(2000), 3); _tableTicktes = _tableClient.GetTableReference("TicketsRead"); _tableEvents = _tableClient.GetTableReference("EventsRead"); _tableMyEvents = _tableClient.GetTableReference("MyEventsRead"); _tableTicktes.CreateIfNotExists(); _tableEvents.CreateIfNotExists(); _tableMyEvents.CreateIfNotExists(); _queueClient = _storageAccount.CreateCloudQueueClient(); _queue = _queueClient.GetQueueReference("ticket-online"); _queue.CreateIfNotExists(); _cache = cacheService; }
public async Task CloudQueuePeekMessagesAsync() { CloudQueueClient client = GenerateCloudQueueClient(); string name = GenerateNewQueueName(); CloudQueue queue = client.GetQueueReference(name); await queue.CreateAsync(); int messageCount = 30; List <CloudQueueMessage> emptyMessages = (await queue.PeekMessagesAsync(messageCount)).ToList(); Assert.AreEqual(0, emptyMessages.Count); List <string> messageContentList = new List <string>(); for (int i = 0; i < messageCount; i++) { string messageContent = i.ToString(); CloudQueueMessage message = new CloudQueueMessage(messageContent); await queue.AddMessageAsync(message); VerifyAddMessageResult(message); messageContentList.Add(messageContent); } List <CloudQueueMessage> receivedMessages = (await queue.PeekMessagesAsync(messageCount)).ToList(); Assert.AreEqual(messageCount, receivedMessages.Count); for (int i = 0; i < messageCount; i++) { Assert.IsTrue(messageContentList.Contains(receivedMessages[i].AsString)); } await queue.DeleteAsync(); }
public async Task CloudQueueAddMessageVerifyContent() { CloudQueueClient client = GenerateCloudQueueClient(); string name = GenerateNewQueueName(); CloudQueue queue = client.GetQueueReference(name); try { await queue.CreateIfNotExistsAsync(); string msgContent = Guid.NewGuid().ToString("N"); CloudQueueMessage message = new CloudQueueMessage(msgContent); message.NextVisibleTime = null; await queue.AddMessageAsync(message); VerifyAddMessageResult(message); Assert.IsTrue(message.AsString == msgContent); } finally { queue.DeleteIfExistsAsync().Wait(); } }
public async Task CloudQueueClientListQueuesBasicAsync() { string prefix = TestHelper.GenerateNewQueueName(); List <string> queueNames = new List <string>(); int count = 2; for (int i = 0; i < count; i++) { queueNames.Add(prefix + i); } QueueResultSegment emptyResults = await DefaultQueueClient.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null); Assert.AreEqual <int>(0, emptyResults.Results.Count()); foreach (string name in queueNames) { await DefaultQueueClient.GetQueueReference(name).CreateAsync(); } QueueResultSegment results = await DefaultQueueClient.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null); foreach (var queue in results.Results) { if (queueNames.Remove(queue.Name)) { await queue.DeleteAsync(); } else { Assert.Fail(); } } Assert.AreEqual <int>(count, results.Results.Count()); }
public void CloudQueueAddEncrypted64KMessage() { // Create the Key to be used for wrapping. SymmetricKey aesKey = new SymmetricKey("symencryptionkey"); CloudQueueClient client = GenerateCloudQueueClient(); string name = GenerateNewQueueName(); CloudQueue queue = client.GetQueueReference(name); try { queue.CreateIfNotExists(); string inputMessage = new string('a', 64 * 1024); CloudQueueMessage message = new CloudQueueMessage(inputMessage); queue.EncodeMessage = false; QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null); QueueRequestOptions options = new QueueRequestOptions() { EncryptionPolicy = policy }; // Add message queue.AddMessage(message, null, null, null, null); // Add encrypted Message TestHelper.ExpectedException <ArgumentException>( () => queue.AddMessage(message, null, null, options, null), "Adding an encrypted message that exceeds message limits should throw"); } finally { queue.DeleteIfExists(); } }
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().AsTask().Wait(); } }
private void InitializeTweetDestinationQueue() { _queueClient = _tweetsQueueStorageAccount.CreateCloudQueueClient(); _tweetQueue = _queueClient.GetQueueReference("tweetsqueue"); _tweetQueue.CreateIfNotExists(); }
/// <summary> /// Get the message from IN Queue /// </summary> /// <param name="myqueueClient">QueClient</param> /// <returns>New Message, it can be null if it has not message</returns> private CloudQueueMessage GetNewMessage(CloudQueueClient myqueueClient) { CloudQueueMessage currentMessage=null; try { InWorkQueue = myqueueClient.GetQueueReference(myConfigData.inWorkQueueName); currentMessage = InWorkQueue.GetMessage(); } catch (Exception X) { string txt = string.Format("[{0}] at {1} has an error: {2}", this.GetType().FullName, "GetNewMessage", X.Message); Trace.TraceError(txt); } return currentMessage; }
/// <summary> /// Initialize the appender based on the options set /// </summary> /// <remarks> /// <para> /// This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object /// activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must /// be called on this object after the configuration properties have /// been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this /// object is in an undefined state and must not be used. /// </para> /// <para> /// If any of the configuration properties are modified then /// <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again. /// </para> /// </remarks> public override void ActivateOptions() { base.ActivateOptions(); _account = CloudStorageAccount.Parse(ConnectionString); _queueClient = _account.CreateCloudQueueClient(); _queue = _queueClient.GetQueueReference(QueueName.ToLower()); _queue.CreateIfNotExists(); }
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(); } }
private void InitializeSearchIndexQueue() { _queueClient = _storageAccount.CreateCloudQueueClient(); _searchIndexQueue = _queueClient.GetQueueReference("searchindexqueue"); _searchIndexQueue.CreateIfNotExists(); }
public void QueueContinuationTokenVerifyXmlWithinXml() { CloudQueueClient client = GenerateCloudQueueClient(); string prefix = "dotnetqueuetest" + Guid.NewGuid().ToString("N"); List <string> queueNames = new List <string>(); int count = 30; for (int i = 0; i < count; i++) { queueNames.Add(prefix + i); client.GetQueueReference(prefix + i).Create(); } QueueContinuationToken token = null; List <CloudQueue> results = new List <CloudQueue>(); do { QueueResultSegment segment = client.ListQueuesSegmented(prefix, QueueListingDetails.None, 5, token, null, null); token = segment.ContinuationToken; results.AddRange(segment.Results); if (token != null) { Assert.AreEqual(null, token.GetSchema()); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; StringBuilder sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { writer.WriteStartElement("test1"); writer.WriteStartElement("test2"); token.WriteXml(writer); writer.WriteEndElement(); writer.WriteEndElement(); } using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()))) { token = new QueueContinuationToken(); reader.ReadStartElement(); reader.ReadStartElement(); token.ReadXml(reader); reader.ReadEndElement(); reader.ReadEndElement(); } } }while (token != null); foreach (CloudQueue queue in results) { if (queueNames.Remove(queue.Name)) { queue.Delete(); } else { Assert.Fail(); } } Assert.AreEqual <int>(0, queueNames.Count); }
public AzureQueueService(CloudQueueClient queueClient, string queueName) { _queue = queueClient.GetQueueReference(queueName); _queue.CreateIfNotExists(); }
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(); } }
CloudQueue GetQueueReference(AzureQueueAccessInformation accessInfo) { var creds = new StorageCredentials(accessInfo.Token); var uri = new Uri(accessInfo.StorageUri.PrimaryUri); var client = new CloudQueueClient(uri, creds); var queue = client.GetQueueReference(accessInfo.QueueName); return queue; }
private CloudQueue GetCloudQueue() { var queueClient = new CloudQueueClient(this.UriQueue, new StorageCredentials(this.QueueSas)); var queue = queueClient.GetQueueReference("messagequeue"); queue.CreateIfNotExists(); return queue; }