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