private IEnumerable <Task> DeleteAllQueues() { CloudQueueClient queueClient = _storageAccount.CreateCloudQueueClient(); IEnumerable <CloudQueue> allQueues = queueClient.ListQueues(); return(allQueues.Select(q => Task.Run(() => q.DeleteAndWaitForCompletion()))); }
private void Clean() { CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); foreach (var queue in queueClient.ListQueues(TestArtifactsPrefix)) { queue.Delete(); } CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer hostContainer = blobClient.GetContainerReference("azure-webjobs-hosts"); foreach (CloudBlockBlob lockBlob in hostContainer.ListBlobs(string.Format("locks/{0}", TestHostId), useFlatBlobListing: true)) { try { lockBlob.Delete(); } catch (StorageException) { // best effort - might fail if there is an active // lease on the blob } } }
public void Dispose() { foreach (var testqueue in _queueClient.ListQueues(TestArtifactPrefix)) { testqueue.Delete(); } }
public static IEnumerable <string> GetAll(string account, string key) { CloudQueueClient queueClient = Client.GetQueueClient(account, key); foreach (CloudQueue queue in queueClient.ListQueues()) { yield return(queue.Name); } }
// Get all queues public static IEnumerable <CloudQueue> getQueues() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the queue client CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); return(queueClient.ListQueues()); }
public void Drop() { CloudQueueClient queueClient = account.CreateCloudQueueClient(); if (queueClient.ListQueues().Select(c => c.Name).Contains(queueName)) { CloudQueue queue = queueClient.GetQueueReference(queueName); queue.Delete(); } }
public void Dispose() { if (storageAccount != null) { CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); foreach (var queue in queueClient.ListQueues(TestArtifactsPrefix)) { queue.Delete(); } } }
// List public void Listqueue() { CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); Console.WriteLine("Create a list for queue "); foreach (var queue in queueClient.ListQueues()) { Console.WriteLine(queue.Uri + "======" + queue.Name); } }
// Queues public string[] GetQueueNames() { CloudQueueClient queueClient = new CloudQueueClient(queueURI, creds); try { return(queueClient.ListQueues().Select(x => x.Name).ToArray()); } catch (Exception e) { throw new StorageAccountException("Unable to retrieve queue names.", e); } }
public void Dispose() { _functionStarted.Dispose(); _functionCompleted.Dispose(); if (_storageAccount != null) { CloudQueueClient queueClient = _storageAccount.CreateCloudQueueClient(); foreach (var testQueue in queueClient.ListQueues(TestArtifactPrefix)) { testQueue.Delete(); } } }
public void Dispose() { CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient(); foreach (var testContainer in blobClient.ListContainers(TestArtifactsPrefix)) { testContainer.Delete(); } CloudQueueClient queueClient = StorageAccount.CreateCloudQueueClient(); foreach (var testQueue in queueClient.ListQueues(TestArtifactsPrefix)) { testQueue.Delete(); } }
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 static void DeleteAllQueue() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the queue client. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve reference to a previously created container. IEnumerable <CloudQueue> queueList = queueClient.ListQueues(); int count = queueList.Count(); foreach (CloudQueue queue in queueList) { queue.Delete(); Console.Write("\r{0} - Queue Remaining to delete ", count--); } }
public void QueueTest() { AzureService azureService = new AzureService(Settings.Default.AzureAccountName, Settings.Default.AzureAccountKey); CloudQueueClient cloudQueueClient = azureService.GetCloudQueueClient(); IEnumerable <CloudQueue> queues = cloudQueueClient.ListQueues(); foreach (var queue in queues) { testContextInstance.WriteLine("{0}", queue.Name); } CloudQueue queue1 = cloudQueueClient.GetQueueReference("testqueue"); //Check whether the queue exists, and create it if it does not. if (!queue1.Exists()) { queue1.Create(); } CloudQueueMessage message = new CloudQueueMessage("This is a test"); queue1.AddMessage(message); String songInfo = String.Format("{0},{1}", @"c:\music\song.mp3", 34); message = new CloudQueueMessage(songInfo); queue1.AddMessage(message); while (true) { CloudQueueMessage message1 = queue1.GetMessage(); if (null == message1) { break; } testContextInstance.WriteLine("{0}", message1.AsString); queue1.DeleteMessage(message1); } }
//https://msazure.visualstudio.com/One/_git/AzureStack-Services-Storage?path=%2Fsrc%2Fsdx%2Fbase%2Fwoss%2Ftest%2Ftests%2FWFE%2FHorizontalBVT%2FAccountKeyTests.cs&version=GBmaster&_a=contents /// <summary> /// Make a couple of requests to the blob, queue, and table services, expecting success. /// </summary> /// <param name="account">The account through which the services will be accessed.</param> internal void MakeServiceRequestsExpectSuccess(CloudStorageAccount account) { // Make blob service requests CloudBlobClient blobClient = account.CreateCloudBlobClient(); // blobClient.ListContainersSegmentedAsync(); blobClient.ListContainers().Count(); blobClient.GetServiceProperties(); // Make queue service requests CloudQueueClient queueClient = account.CreateCloudQueueClient(); queueClient.ListQueues().Count(); queueClient.GetServiceProperties(); // Make table service requests CloudTableClient tableClient = account.CreateCloudTableClient(); tableClient.ListTables().Count(); tableClient.GetServiceProperties(); }
public static bool ClearAllQueues() { try { CloudStorageAccount account = CloudStorageAccount.Parse(Microsoft.Azure.CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudQueueClient queueClient = account.CreateCloudQueueClient(); foreach (var item in queueClient.ListQueues()) { string strQueueName = item.Name; CloudQueue queue = queueClient.GetQueueReference(strQueueName); queue.Delete(); } return(true); } catch (Exception ex) { throw ex; } }
private static void Clean(CloudStorageAccount account) { CloudBlobClient blobClient = account.CreateCloudBlobClient(); foreach (var testContainer in blobClient.ListContainers(TestArtifactPrefix)) { testContainer.Delete(); } CloudTableClient tableClient = account.CreateCloudTableClient(); foreach (var table in tableClient.ListTables(TestArtifactPrefix)) { table.Delete(); } CloudQueueClient queueClient = account.CreateCloudQueueClient(); foreach (var queue in queueClient.ListQueues(TestArtifactPrefix)) { queue.Delete(); } }
// List queues. // Return true on success, false if not found, throw exception on error. public bool ListQueues(out List <CloudQueue> queueList) { queueList = new List <CloudQueue>(); try { IEnumerable <CloudQueue> queues = QueueClient.ListQueues(); if (queues != null) { queueList.AddRange(queues); } return(true); } catch (StorageClientException ex) { if ((int)ex.StatusCode == 404) { return(false); } throw; } }
public IEnumerable <CloudQueue> ListQueues() { return(cloudQueueClient.ListQueues()); }
/// <summary> /// List storage queues /// </summary> /// <param name="prefix">Queue name prefix</param> /// <param name="queueListingDetails">Queue listing details</param> /// <param name="options">Queue request options</param> /// <param name="operationContext">Operation context</param> /// <returns>An enumerable collection of the queues in the storage account.</returns> public IEnumerable <CloudQueue> ListQueues(string prefix, QueueListingDetails queueListingDetails, QueueRequestOptions options, OperationContext operationContext) { return(queueClient.ListQueues(prefix, queueListingDetails, options, operationContext)); }
public IEnumerable <IAzureQueue> ListQueues() { return(_cloudQueueClient.ListQueues() .Select(q => new HostedAzureQueue(q)) .ToArray()); }
/// <summary> /// Cleanup the Azure storage including both queue and blob. /// </summary> private async Task Cleanup() { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Try to cleanup the Azure storage."); ClusterInfoContract clusterInfo = await this.helper.GetClusterInfoAsync(); string clusterName = clusterInfo.ClusterName; Guid clusterId; if (!Guid.TryParse(clusterInfo.ClusterId, out clusterId)) { BrokerTracing.TraceError( "[AzureStorageCleaner].Cleanup: clusterInfo.ClusterId is not a valid GUID string."); throw new ArgumentException("clusterInfo.ClusterId", "clusterInfo.ClusterId is not a valid GUID string."); } var connectionString = clusterInfo.AzureStorageConnectionString; if (string.IsNullOrEmpty(connectionString)) { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Azure storage connection string is not set."); // no need to do anything if the connection string is not set return; } string prefix = SoaHelper.GetResponseStoragePrefix(clusterId.ToString()); string prefixAQ = SoaHelper.GetAzureQueueStoragePrefix(clusterId.ToString().ToLower().GetHashCode()); CloudStorageAccount account = CloudStorageAccount.Parse(connectionString); CloudQueueClient queueClient = account.CreateCloudQueueClient(); queueClient.DefaultRequestOptions.RetryPolicy = DefaultRetryPolicy; var queues = queueClient.ListQueues(prefix); var queuesAQ = queueClient.ListQueues(prefixAQ); CloudBlobClient blobClient = account.CreateCloudBlobClient(); blobClient.DefaultRequestOptions.RetryPolicy = DefaultRetryPolicy; var containers = blobClient.ListContainers(prefix, ContainerListingDetails.None, null, null); var containersAQ = blobClient.ListContainers(prefixAQ, ContainerListingDetails.None, null, null); Dictionary <int, int> nonTerminatedSession; if (queues.Count <CloudQueue>() > 0 || containers.Count <CloudBlobContainer>() > 0 || queuesAQ.Count <CloudQueue>() > 0 || containersAQ.Count <CloudBlobContainer>() > 0) { // if there are queue/container candidates for deleting, get // following info from session service nonTerminatedSession = await this.helper.GetNonTerminatedSession(); } else { return; } // cleanup storage queue foreach (CloudQueue queue in queues) { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Azure storage queue name is {0}", queue.Name); if (this.IsSessionTerminated(nonTerminatedSession, prefix, queue.Name)) { try { queue.Delete(); } catch (Exception e) { BrokerTracing.TraceError( "[AzureStorageCleaner].Cleanup: Deleting queue {0} failed, {1}", queue.Name, e); } } } // cleanup storage blob container foreach (CloudBlobContainer container in containers) { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Azure storage container name is {0}", container.Name); if (this.IsSessionTerminated(nonTerminatedSession, prefix, container.Name)) { try { container.Delete(); } catch (Exception e) { BrokerTracing.TraceError( "[AzureStorageCleaner].Cleanup: Deleting container {0} failed, {1}", container.Name, e); } } } // cleanup storage queue for the http clients foreach (CloudQueue queue in queuesAQ) { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Azure storage queue name is {0}", queue.Name); if (this.IsSessionTerminatedAQ(nonTerminatedSession, prefixAQ, queue.Name)) { try { queue.Delete(); } catch (Exception e) { BrokerTracing.TraceError( "[AzureStorageCleaner].Cleanup: Deleting queue {0} failed, {1}", queue.Name, e); } } } // cleanup storage blob container for the http clients foreach (CloudBlobContainer container in containersAQ) { BrokerTracing.TraceVerbose( "[AzureStorageCleaner].Cleanup: Azure storage container name is {0}", container.Name); if (this.IsSessionTerminatedAQ(nonTerminatedSession, prefixAQ, container.Name)) { try { container.Delete(); } catch (Exception e) { BrokerTracing.TraceError( "[AzureStorageCleaner].Cleanup: Deleting container {0} failed, {1}", container.Name, e); } } } }
public IEnumerable <String> ListQueues() { return(cloudQueueClient.ListQueues().Select(cq => cq.Name)); }
public System.Collections.Generic.IEnumerable <CloudQueue> ListAllQueues() { return(_cloudQueueClient.ListQueues()); }
/// <summary> /// Check if the Azure storage connection string is valid. /// </summary> private async Task ValidateConnectionString() { int sessionId = this.sharedData.BrokerInfo.SessionId; string sessionNode = await this.context.ResolveSessionLauncherNodeAsync(); string certThrumbprint = await this.context.GetSSLThumbprint(); string storageConnectionString = this.sharedData.BrokerInfo.AzureStorageConnectionString; // CommonClusterManagerHelper.GetAzureStorageConnectionString(scheduler); if (string.IsNullOrEmpty(storageConnectionString)) { this.connectionStringValid = false; BrokerTracing.TraceError( "[DispatcherManager].ValidateConnectionString: Azure storage connection string is missed."); // set job's progress message if Azure connection string is missed using (HpcSchedulerAdapterInternalClient client = new HpcSchedulerAdapterInternalClient(sessionNode, certThrumbprint)) { await client.SetJobProgressMessage(sessionId, SR.MissAzureStorageConnectionString); } } else { try { this.azureQueueManager.StorageConnectionString = storageConnectionString; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString); CloudQueueClient client = storageAccount.CreateCloudQueueClient(); client.ListQueues().Any <CloudQueue>(); this.connectionStringValid = true; } catch (StorageException e) { string errorCode = BurstUtility.GetStorageErrorCode(e); if (errorCode == StorageErrorCodeStrings.AuthenticationFailed) { this.connectionStringValid = false; BrokerTracing.TraceError( "[DispatcherManager].ValidateConnectionString: Access key in Azure storage connection string is invalid."); // set job's progress message if Azure connection string is invalid using (HpcSchedulerAdapterInternalClient client = new HpcSchedulerAdapterInternalClient(sessionNode, certThrumbprint)) { await client.SetJobProgressMessage(sessionId, SR.InvalidAzureStorageConnectionString); } } else if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.BadGateway) { this.connectionStringValid = false; BrokerTracing.TraceError( "[DispatcherManager].ValidateConnectionString: Account name in Azure storage connection string is invalid."); // set job's progress message if Azure connection string is invalid using (HpcSchedulerAdapterInternalClient client = new HpcSchedulerAdapterInternalClient(sessionNode, certThrumbprint)) { await client.SetJobProgressMessage(sessionId, SR.InvalidAzureStorageConnectionString); } } else { this.connectionStringValid = true; BrokerTracing.TraceWarning( "[DispatcherManager].ValidateConnectionString: Error occurs when check storage connection string, {0}", e); } } } }
public async Task <bool> Start(ConfigurationOptions config, CancellationToken cancellationToken) { CloudStorageAccount storageAccount; try { storageAccount = CloudStorageAccount.Parse(config.ConnectionString); } catch (FormatException ex) { _console.ColoredWriteLine($"<r>Error parsing the connection string: <w>{ex.Message}</w></r>"); return(false); } Console.Clear(); Console.Title = $"Azure Storage Queue Monitor{(!string.IsNullOrWhiteSpace(config.Title) ? $" -- {config.Title}" : "")}"; Console.CursorVisible = false; Dictionary <string, QueueInfo> queueInfos = new Dictionary <string, QueueInfo>(); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); int iterations = 0; Stopwatch sw = new Stopwatch(); while (true) { await Task.Yield(); if (cancellationToken.IsCancellationRequested) { return(true); } sw.Restart(); iterations++; if (iterations == 50) { iterations = 0; queueInfos.Clear(); } List <CloudQueue> queues = queueClient.ListQueues().ToList(); foreach (var queue in queues) { try { queue.FetchAttributes(); } catch (StorageException sex) when(sex.Message.Contains("The specified queue does not exist")) { if (queueInfos.ContainsKey(queue.Name)) { queueInfos.Remove(queue.Name); } } string name = queue.Name; if (config.IgnoredQueues?.Any(i => Regex.IsMatch(name, i)) ?? false) { continue; } int count = queue.ApproximateMessageCount ?? 0; if (!queueInfos.ContainsKey(name)) { bool isImportant = false; if (config.ImportantQueues?.Any(i => Regex.IsMatch(name, i)) ?? false) { isImportant = true; } string groupName = "NOT GROUPED"; int groupOrder = int.MaxValue; if (config.GroupQueues) { foreach (var queueGroup in config.QueueGroups) { if (queueGroup.Queues.Any(q => Regex.IsMatch(name, q))) { groupName = queueGroup.GroupName; groupOrder = queueGroup.Order; continue; } } } queueInfos.Add(name, new QueueInfo { Name = name, FirstCount = count, CurrentCount = count, IsImportant = isImportant, GroupName = groupName, GroupOrder = groupOrder }); } else { var info = queueInfos[name]; if (count > info.FirstCount) { info.FirstCount = count; info.IncreasedCount = true; } else { info.IncreasedCount = false; } info.DecreasedCount = count < info.CurrentCount; info.CurrentCount = count; } } PrintQueues(config, queueInfos, iterations); if (config.ExportCountData) { if (_previousQueueCount != queueInfos.Count) { _exportFullPath = null; } ExportCountData(config, queueInfos); } _previousQueueCount = queueInfos.Count; sw.Stop(); long sleepInterval = config.Interval - sw.ElapsedMilliseconds; if (sleepInterval > 0) { await Task.Delay(config.Interval, cancellationToken); } } }
/// <summary> /// Test some of the queue storage operations. /// </summary> public async Task RunQueueStorageAdvancedOpsAsync() { try { //***** Setup *****// Console.WriteLine("Getting reference to the storage account."); // Retrieve storage account information from connection string // How to create a storage connection string - http://msdn.microsoft.com/en-us/library/azure/ee758697.aspx CloudStorageAccount storageAccount = Common.CreateStorageAccountFromConnectionString(CloudConfigurationManager.GetSetting("StorageConnectionString")); Console.WriteLine("Instantiating queue client."); Console.WriteLine(string.Empty); // Create a queue client for interacting with the queue service. CloudQueueClient cloudQueueClient = storageAccount.CreateCloudQueueClient(); // Create 3 queues. // Create the queue name -- use a guid in the name so it's unique. string baseQueueName = "demotest-" + System.Guid.NewGuid().ToString(); // Keep a list of the queues so you can compare this list // against the list of queues that we retrieve. List <string> queueNames = new List <string>(); for (int i = 0; i < 3; i++) { // Set the name of the queue, then add it to the generic list. string queueName = baseQueueName + "-0" + i; queueNames.Add(queueName); // Create the queue with this name. Console.WriteLine("Creating queue with name {0}", queueName); CloudQueue cloudQueue = cloudQueueClient.GetQueueReference(queueName); try { await cloudQueue.CreateIfNotExistsAsync(); Console.WriteLine(" Queue created successfully."); } catch (StorageException exStorage) { Common.WriteException(exStorage); Console.WriteLine("Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating queue."); Common.WriteException(ex); throw; } } Console.WriteLine(string.Empty); Console.WriteLine("List of queues in the storage account:"); // List the queues for this storage account IEnumerable <CloudQueue> cloudQueueList = cloudQueueClient.ListQueues(); try { foreach (CloudQueue cloudQ in cloudQueueList) { Console.WriteLine("Cloud Queue name = {0}", cloudQ.Name); } } catch (Exception ex) { Console.WriteLine(" Exception thrown listing queues."); Common.WriteException(ex); throw; } // Now clean up after yourself, using the list of queues that you created in case there were other queues in the account. foreach (string oneQueueName in queueNames) { CloudQueue cloudQueue = cloudQueueClient.GetQueueReference(oneQueueName); cloudQueue.DeleteIfExists(); } } catch (Exception ex) { Console.WriteLine(" Exception thrown. Message = {0}{1} Strack Trace = {2}", ex.Message, Environment.NewLine, ex.StackTrace); } }
// The Azure Functions runtime uses this storage account connection string for all functions // except for HTTP triggered functions. // The storage account must be a general-purpose one that supports blobs, queues, and tables. // See Storage account and Storage account requirements. // AzureWebJobsDashboard // Optional storage account connection string for storing logs and displaying them in the Monitor tab in the portal. // The storage account must be a general-purpose one that supports blobs, queues, and tables. // See Storage account and Storage account requirements. //Functions uses Storage for operations such as managing triggers and logging function executions. internal StorageAccountsValidation MakeServiceRequestsExpectSuccess(string connectionKey, string connectionString) { string storageSymptoms = String.Empty; int status = 0; string postfixStatement = "Please make sure this is a general-purpose storage account."; //if (connectionKey.Equals("AzureWebJobsStorage", StringComparison.OrdinalIgnoreCase)) //{ //} try { if (string.IsNullOrWhiteSpace(connectionString)) { // return Task.FromResult<StorageAccountsValidation> (new StorageAccountsValidation { }); return(new StorageAccountsValidation { }); } CloudStorageAccount account = CloudStorageAccount.Parse(connectionString); // Make blob service requests try { CloudBlobClient blobClient = account.CreateCloudBlobClient(); // blobClient.ListContainersSegmentedAsync(); // blobClient.ListContainers().Count(); blobClient.GetServiceProperties(); } catch (Exception ex) { storageSymptoms += "Blob endpoint is not reachable. Make sure the firewall on this storage account is not misconfigured."; throw ex; } try { // Make queue service requests CloudQueueClient queueClient = account.CreateCloudQueueClient(); queueClient.ListQueues().Count(); queueClient.GetServiceProperties(); } catch (Exception ex) { storageSymptoms += "Queue is not enabled. "; throw ex; } try { // Make table service requests CloudTableClient tableClient = account.CreateCloudTableClient(); tableClient.ListTables().Count(); tableClient.GetServiceProperties(); } catch (Exception ex) { storageSymptoms += "Table is not enabled."; throw ex; } try { // Not sure if this is only required for consumption // When using a Consumption plan function definitions are stored in File Storage. CloudFileClient fileClient = account.CreateCloudFileClient(); fileClient.ListShares().Count(); fileClient.GetServiceProperties(); } catch (Exception ex) { storageSymptoms += "File is not enabled."; throw ex; } storageSymptoms = "Storage connection string validation passed!"; } catch (Exception ex) { storageSymptoms += "\n"; storageSymptoms += postfixStatement; status = 1; } StorageAccountsValidation result = new StorageAccountsValidation { AppSettingsKey = connectionKey, Mandatory = false, AccountName = connectionString.Split(new string[] { "AccountName=", ";AccountKey=" }, StringSplitOptions.RemoveEmptyEntries)[1], Message = storageSymptoms, Status = status }; //return Task.FromResult(result); return(result); }
/// <summary> /// Acts upon command line arguments. /// </summary> /// <param name="args">Command line arguments.</param> private static void Main(string[] args) { // Create our CloudQueueClient object. // REVIEW: Hard-coded connection string index "Ironclad". string connectionString = null; ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["Ironclad"]; if (settings != null) { connectionString = settings.ConnectionString; } if (string.IsNullOrEmpty(connectionString)) { throw new ConfigurationException("Azure connection string missing from your .exe.config file!"); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); switch (args.Length) { case 0: Status(queueClient.ListQueues()); break; case 2: { CloudQueue queue = queueClient.GetQueueReference(args[1]); if (!queue.Exists()) { Console.WriteLine("No such queue '{0}'", args[1]); return; } queue.FetchAttributes(); switch (args[0]) { case "clear": case "Clear": queue.Clear(); Console.WriteLine("Queue '{0}' cleared.", queue.Name); break; case "peek": case "Peek": int numberToPeekAt = (queue.ApproximateMessageCount != null) ? (int)queue.ApproximateMessageCount : 0; Console.WriteLine("Queue '{0}' contains {1} messages:", queue.Name, numberToPeekAt); if (numberToPeekAt != 0) { // Peek API only allows a maximum of 32 messages to be peeked at. numberToPeekAt = Math.Min(numberToPeekAt, 32); foreach (CloudQueueMessage message in queue.PeekMessages(numberToPeekAt)) { Console.WriteLine( "\t{0} {1} {2}", message.Id, message.InsertionTime, message.ExpirationTime); } } break; case "status": case "Status": Status(new CloudQueue[] { queue }); break; default: Usage(); break; } } break; default: Usage(); break; } }
public int GetExistingQueueCount() { List <CloudQueue> queues = client.ListQueues().ToList(); return(queues.Count); }