protected virtual void configureQueue(CloudStorageAccount storageAccount) { // Create the queue client this.queueClient = storageAccount.CreateCloudQueueClient(); this.queue = createQueue(this.queueClient, this.queueName); }
public FakeStorageQueue(MemoryQueueStore store, string queueName, IStorageQueueClient parent) { _store = store; _queueName = queueName; _parent = parent; _sdkObject = new CloudQueue(new Uri("http://localhost/" + queueName)); }
private void InitQueue() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); queue = queueClient.GetQueueReference("jobqueue"); queue.CreateIfNotExists(); }
public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount; ConfigureDiagnostics(); // Read storage account configuration settings Trace.TraceInformation("Initializing storage account in WorkerC"); var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue( "StorageConnectionString" )); // Initialize queue storage Trace.TraceInformation("Creating queue client in WorkerC"); var queueClient = storageAccount.CreateCloudQueueClient(); subscribeQueue = queueClient.GetQueueReference("subscribequeue"); // Initialize table storage Trace.TraceInformation("Creating table client in WorkerC"); var tableClient = storageAccount.CreateCloudTableClient(); subscribersTable = tableClient.GetTableReference("Subscribers"); Trace.TraceInformation("WorkerC: Creating blob container, queue, tables, if they don't exist."); subscribeQueue.CreateIfNotExists(); subscribersTable.CreateIfNotExists(); return base.OnStart(); }
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 override bool OnStart() { // Set the maximum number of concurrent connections. ServicePointManager.DefaultConnectionLimit = 12; // Read database connection string and open database. var dbConnString = CloudConfigurationManager.GetSetting("TCWAdminPortalDbConnectionString"); _dbContext = new TCWAdminContext(dbConnString); // Open storage account using credentials from .cscfg file. var storageAccount = CloudStorageAccount.Parse (RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); Trace.TraceInformation("Creating images blob container"); var blobClient = storageAccount.CreateCloudBlobClient(); _imagesBlobContainer = blobClient.GetContainerReference("images"); if (_imagesBlobContainer.CreateIfNotExists()) { // Enable public access on the newly created "images" container. _imagesBlobContainer.SetPermissions( new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); } Trace.TraceInformation("Creating images queue"); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); _imagesQueue = queueClient.GetQueueReference("images"); _imagesQueue.CreateIfNotExists(); Trace.TraceInformation("Storage initialized"); return base.OnStart(); }
static string RequestSasToken(CloudQueue queue) { // Omitting any authentication code since this is beyond the scope of // this sample code // creating a shared access policy that expires in 1 day. // No start time is specified, which means that the token is valid immediately. // The policy specifies full permissions. SharedAccessQueuePolicy policy = new SharedAccessQueuePolicy() { SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-15), SharedAccessExpiryTime = DateTime.UtcNow.AddDays(1.0), Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update | SharedAccessQueuePermissions.ProcessMessages }; // Generate the SAS token. No access policy identifier is used which // makes it a non-revocable token // limiting the table SAS access to only the request customer's id string sasToken = queue.GetSharedAccessSignature(policy); return sasToken; }
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); }
/// <summary> /// Constructs a new instance /// </summary> /// <param name="queue">The <see cref="CloudQueue"/> the <see cref="QueueProcessor"/> will operate on.</param> /// <param name="trace">The <see cref="TraceWriter"/> to write to.</param> /// <param name="queueConfiguration">The queue configuration.</param> /// <param name="poisonQueue">The queue to move messages to when unable to process a message after the maximum dequeue count has been exceeded. May be null.</param> internal QueueProcessorFactoryContext(CloudQueue queue, TraceWriter trace, IQueueConfiguration queueConfiguration, CloudQueue poisonQueue = null) : this(queue, trace, poisonQueue) { BatchSize = queueConfiguration.BatchSize; MaxDequeueCount = queueConfiguration.MaxDequeueCount; NewBatchThreshold = queueConfiguration.NewBatchThreshold; }
public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount; // Read storage account configuration settings ConfigureDiagnostics(); Trace.TraceInformation("Initializing storage account in worker role B"); var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); // Initialize queue storage Trace.TraceInformation("Creating queue client."); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); sendEmailQueue = queueClient.GetQueueReference("azuremailqueue"); subscribeQueue = queueClient.GetQueueReference("azuremailsubscribequeue"); // Initialize blob storage CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("azuremailblobcontainer"); // Initialize table storage var tableClient = storageAccount.CreateCloudTableClient(); mailingListTable = tableClient.GetTableReference("mailinglist"); messageTable = tableClient.GetTableReference("message"); messagearchiveTable = tableClient.GetTableReference("messagearchive"); Trace.TraceInformation("WorkerB: Creating blob container, queue, tables, if they don't exist."); blobContainer.CreateIfNotExists(); sendEmailQueue.CreateIfNotExists(); subscribeQueue.CreateIfNotExists(); this.messageTable.CreateIfNotExists(); this.mailingListTable.CreateIfNotExists(); this.messagearchiveTable.CreateIfNotExists(); return base.OnStart(); }
protected static int getQueueLength(CloudQueue queue) { queue.FetchAttributes(); var messageCount = queue.ApproximateMessageCount; return messageCount ?? 0; }
public static async Task ProcessRequestAsync(HttpContext Context, string Action) { var form = Context.Request.Form; Context.Response.ContentType = "text/javascript"; switch (Action) { case Forms.TakeThePledge.Action.Form: var businessName = form[Forms.TakeThePledge.Keys.BusinessName]; var address = form[Forms.TakeThePledge.Keys.Address]; var manager = form[Forms.TakeThePledge.Keys.OwnerManagerName]; var phoneNumber = form[Forms.TakeThePledge.Keys.PhoneNumber]; var email = form[Forms.TakeThePledge.Keys.Email]; var website = form[Forms.TakeThePledge.Keys.Website]; string message = $"Business Name: {businessName}\r\nAddress: {address}\r\nOwner/Manager: {manager}\r\nPhone Number: {phoneNumber}\r\nEmail: {email}\r\nWebsite: {website}"; try { var e = new Site.Email() { To = Application.TakeThePledge.Form.EmailTo, Subject = "New Business Took Bag Free Portsmouth Pledge", Body = message }; if (_queue == null) { _queue = CloudStorageAccount.Parse($"DefaultEndpointsProtocol=https;AccountName={Application.Queue.Name};AccountKey={Application.Queue.Key}").CreateCloudQueueClient().GetQueueReference(Application.Queue.Name); } await _queue.AddMessageAsync(new CloudQueueMessage(JsonConvert.SerializeObject(e))); await Context.Response.WriteAsync(Response.Substitute(Forms.TakeThePledge.HtmlID.FormContainer, "<div class=\"tac blue\">Thanks! Your information has been received and you'll be contacted shortly.</div>")); } catch { await Context.Response.WriteAsync(Response.Substitute(Forms.TakeThePledge.HtmlID.FormContainer, $"<div class=\"tac blue\">Sorry, there was an error processing the form.</div>")); } break; } }
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); }
public Crawler() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); table = tableClient.GetTableReference("crawlertable"); table.CreateIfNotExists(); datatable = tableClient.GetTableReference("datatable"); datatable.CreateIfNotExists(); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); urlQueue = queueClient.GetQueueReference("urlqueue"); urlQueue.CreateIfNotExists(); adminQueue = queueClient.GetQueueReference("adminqueue"); adminQueue.CreateIfNotExists(); alreadyVisitedUrls = new HashSet<String>(); disallowedUrls = new HashSet<String>(); errorUrls = new HashSet<String>(); tableSize = 0; totalUrls = 0; counter = 1; compareDate = DateTime.ParseExact("2015-04-01", "yyyy-MM-dd", CultureInfo.InvariantCulture); //Regex to check for valid html document rgx = new Regex(@"^[a-zA-Z0-9\-]+.?(htm|html)?$"); }
public StorageQueueViewModel(CloudQueue queue) { if (queue == null) throw new ArgumentNullException(nameof(queue)); _queue = queue; }
public static void Initialize(string storageConnectionString, string ocrQueueName, string emailQueueName) { storageAccount = CloudStorageAccount.Parse(storageConnectionString); queueClient = storageAccount.CreateCloudQueueClient(); ocrQueue = InitializeQueue(ocrQueueName); emailQueue = InitializeQueue(emailQueueName); }
protected override void configureQueue(CloudStorageAccount storageAccount) { // Create base queue base.configureQueue(storageAccount); // Create additional queue to write results this.resultQueue = createQueue(this.queueClient, this.resultQueueName); }
public ProcessMessage(DbService iDbService, QueueService iQueueService) { _documentClient = iDbService.GetDocumentClient(); _client = iDbService.GetFirebaseClient(); _documentCollection = iDbService.GetDc("LMSCollection", "LMSRegistry"); _sp = iDbService.GetSp(_documentCollection, "Post"); _queue = iQueueService.GetQueue("queue"); }
private void InitializeStorage() { var storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ToString()); var blobClient = storageAccount.CreateCloudBlobClient(); _imagesBlobContainer = blobClient.GetContainerReference("images"); var queueClient = storageAccount.CreateCloudQueueClient(); _requestQueue = queueClient.GetQueueReference("imagerequest"); }
public QueueMessageSource() { var account = MakeAccount(); queue = MakeQueue(account); queue.CreateIfNotExists(); }
public void OneTimeSetup() { queue = client.GetQueueReference("producertest"); factory = new JobFactory(); factory.RegisterJobType(typeof(HelloWho)); factory.RegisterJobType(typeof(MockJob)); }
/// <summary> /// Azure storage queue constructor. /// </summary> /// <param name="queue">Cloud queue object</param> public AzureStorageQueue(CloudQueue queue) { CloudQueue = queue; Name = queue.Name; Uri = queue.Uri; ApproximateMessageCount = queue.ApproximateMessageCount; EncodeMessage = queue.EncodeMessage; }
public QueueHelper(string storageAccountConnectionString) : base(storageAccountConnectionString) { queueClient = base.StorageAccount.CreateCloudQueueClient(); subscribeQueue = queueClient.GetQueueReference(ConfigurationManager.AppSettings["QueueAzuremailsubscribequeue"]); subscribeQueue.CreateIfNotExists(); }
private async Task Initialize() { // Create the queues if they don't exist _queue = _cloudQueueClient.GetQueueReference(UploadConfig.NotificationQueueName); _poisonQueue = _cloudQueueClient.GetQueueReference(PoisionQueueName); await Task.WhenAll(_queue.CreateIfNotExistsAsync(), _poisonQueue.CreateIfNotExistsAsync()).ConfigureAwait(false); _initialized = true; }
public CacheVoteGetter(ApplicationDbContext dbContext) { _dbContext = dbContext; var cloudStorageAccount = CloudStorageAccount.Parse(Startup.Configuration["MicrosoftAzureStorage:devdaydemo_AzureStorageConnectionString"]); var createCloudQueueClient = cloudStorageAccount.CreateCloudQueueClient(); _messageQueue = createCloudQueueClient.GetQueueReference(typeof(Voto).Name.ToLowerInvariant()); }
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(); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // read storage account configuration settings var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("DataConnectionString")); // initialize blob storage CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient(); this.container = blobStorage.GetContainerReference("guestbookpics"); // initialize queue storage CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient(); this.queue = queueStorage.GetQueueReference("guestthumbs"); Trace.TraceInformation("Creating container and queue..."); bool storageInitialized = false; while (!storageInitialized) { try { // create the blob container and allow public access this.container.CreateIfNotExists(); var permissions = this.container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; this.container.SetPermissions(permissions); // create the message queue(s) this.queue.CreateIfNotExists(); storageInitialized = true; } catch (StorageException e) { var requestInformation = e.RequestInformation; var errorCode = requestInformation.ExtendedErrorInformation.ErrorCode;//errorCode = ContainerAlreadyExists var statusCode = (System.Net.HttpStatusCode)requestInformation.HttpStatusCode;//requestInformation.HttpStatusCode = 409, statusCode = Conflict if (statusCode == HttpStatusCode.NotFound) { Trace.TraceError( "Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running. Message: '{0}'", e.Message); System.Threading.Thread.Sleep(5000); } else { throw; } } } return base.OnStart(); }
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 AzureQueue() { var cloudStorageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting(Azure.StorageConnectionString)); var cloudQueueClient= cloudStorageAccount.CreateCloudQueueClient(); _cloudQueue= cloudQueueClient.GetQueueReference(CloudConfigurationManager.GetSetting(Azure.QueueName)); _cloudQueue.CreateIfNotExists(); }
static QueueStorageContext() { CloudStorageAccount account = CloudStorageAccount.Parse( System.Configuration.ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString); CloudQueueClient queueClient = account.CreateCloudQueueClient(); queue = queueClient.GetQueueReference(DetectionQueueName); queue.CreateIfNotExists(); }
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(); } }
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 ImageRepository(CloudTable table, Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer blobContainer, Microsoft.WindowsAzure.Storage.Queue.CloudQueue queue, Interfaces.IConfig config) { if (table == null) { throw new ArgumentNullException("table"); } if (blobContainer == null) { throw new ArgumentNullException("blobContainer"); } if (queue == null) { throw new ArgumentNullException("queue"); } if (config == null) { throw new ArgumentNullException("config"); } _table = table; _blobContainer = blobContainer; _queue = queue; _config = config; }