public void CreateTwoQueues_WithDifferentQueueNameCapitalisations_ShouldCreateTwoQueues() { const string queueName1 = "QUEUE-NAME"; const string queueName2 = "queue-name"; var sqsRequest1 = new CreateQueueRequest(queueName1); var sqsRequest2 = new CreateQueueRequest(queueName2); var response1 = _sqs.CreateQueue(sqsRequest1); var response2 = _sqs.CreateQueue(sqsRequest2); Assert.True(response1.HttpStatusCode == System.Net.HttpStatusCode.OK); Assert.EndsWith(queueName1, response1.QueueUrl); Assert.True(response2.HttpStatusCode == System.Net.HttpStatusCode.OK); Assert.EndsWith(queueName2, response2.QueueUrl); // Find the the queue in the list of queues ListQueuesRequest listQueuesRequest = new ListQueuesRequest(); ListQueuesResponse listQueuesResponse = _sqs.ListQueues(listQueuesRequest); var createdQueue = listQueuesResponse.QueueUrls.Where(q => q.EndsWith(queueName1) || q.EndsWith(queueName2)); Assert.True(createdQueue.Count() == 2); // Cleanup SqsQueueUtils.DeleteQueue(response1.QueueUrl, _sqs); SqsQueueUtils.DeleteQueue(response2.QueueUrl, _sqs); }
public void Test_A_ListQueues_And_Check_For_NonNull_Response() { bool hasCallbackArrived = false; bool actualValue = false; bool expectedValue = true; SQSResponseEventHandler <object, ResponseEventArgs> handler = null; handler = delegate(object sender, ResponseEventArgs args) { ISQSResponse result = args.Response; //Unhook from event. _client.OnSQSResponse -= handler; ListQueuesResponse response = result as ListQueuesResponse; if (null != response) { actualValue = true; } hasCallbackArrived = true; }; //Hook to event _client.OnSQSResponse += handler; //Create request object. ListQueuesRequest listQueue = new ListQueuesRequest(); _client.ListQueues(listQueue); EnqueueConditional(() => hasCallbackArrived); EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue)); EnqueueTestComplete(); }
public static void InvokeListQueues() { NameValueCollection appConfig = ConfigurationManager.AppSettings; // Print the number of Amazon SimpleDB domains. IAmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.USWest2); try { ListQueuesResponse sqsResponse = sqs.ListQueues(new ListQueuesRequest()); int numQueues = 0; numQueues = sqsResponse.QueueUrls.Count; Console.WriteLine("You have " + numQueues + " Amazon SQS queues(s)."); } catch (AmazonSQSException ex) { Console.WriteLine("Caught Exception: " + ex.Message); Console.WriteLine("Response Status Code: " + ex.StatusCode); Console.WriteLine("Error Code: " + ex.ErrorCode); Console.WriteLine("Error Type: " + ex.ErrorType); Console.WriteLine("Request ID: " + ex.RequestId); } Console.WriteLine(); }
private static void UnmarshallResult(XmlUnmarshallerContext context, ListQueuesResponse response) { int originalDepth = context.CurrentDepth; int targetDepth = originalDepth + 1; if (context.IsStartOfDocument) { targetDepth += 2; } while (context.Read()) { if (context.IsStartElement || context.IsAttribute) { if (context.TestExpression("QueueUrl", targetDepth)) { response.QueueUrls.Add(StringUnmarshaller.GetInstance().Unmarshall(context)); continue; } } else if (context.IsEndElement && context.CurrentDepth < originalDepth) { return; } } return; }
public List <string> GetAvailableQueues() { ListQueuesRequest listQueueRequest = new ListQueuesRequest(); ListQueuesResponse listQueueResponse = this.sqsClient.ListQueues(listQueueRequest); return(listQueueResponse.QueueUrls); }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context) { ListQueuesResponse response = new ListQueuesResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.TestExpression("nextToken", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; response.NextToken = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("queues", targetDepth)) { var unmarshaller = new ListUnmarshaller <Queue, QueueUnmarshaller>(QueueUnmarshaller.Instance); response.Queues = unmarshaller.Unmarshall(context); continue; } } return(response); }
private static void UnmarshallResult(XmlUnmarshallerContext context, ListQueuesResponse response) { int originalDepth = context.CurrentDepth; int targetDepth = originalDepth + 1; if (context.IsStartOfDocument) { targetDepth += 2; } while (context.ReadAtDepth(originalDepth)) { if (context.IsStartElement || context.IsAttribute) { if (context.TestExpression("NextToken", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; response.NextToken = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("QueueUrl", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; var item = unmarshaller.Unmarshall(context); response.QueueUrls.Add(item); continue; } } } return; }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context) { ListQueuesResponse response = new ListQueuesResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.IsStartElement) { if (context.TestExpression("ListQueuesResult", 2)) { UnmarshallResult(context, response); continue; } if (context.TestExpression("ResponseMetadata", 2)) { response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context); } } } return(response); }
public override T Unmarshall <T>(IResponseContext context) { try { var response = new ListQueuesResponse(); ResultUnmarshall(context, response); var xmlRootNode = GetXmlElement(context.ContentStream); var queueUrlNodes = xmlRootNode.SelectNodes("ListQueuesResult/QueueUrl"); if (queueUrlNodes != null && queueUrlNodes.Count > 0) { response.QueueUrls = new List <string>(); for (var i = 0; i < queueUrlNodes.Count; i++) { response.QueueUrls.Add(queueUrlNodes[i].InnerText); } } response.ResponseMetadata.RequestId = xmlRootNode.SelectSingleNode("ResponseMetadata/RequestId")?.InnerText; return(response as T); } catch (Exception ex) { throw ErrorUnmarshall(ex.Message, ex, context.StatusCode); } }
public ListQueuesResponse LisQueues() { ListQueuesRequest listQueuesRequest = new ListQueuesRequest(); ListQueuesResponse listQueuesResponse = SQSClient.ListQueues(listQueuesRequest); return(listQueuesResponse); }
public static ListQueuesResponse Unmarshall(UnmarshallerContext context) { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(); listQueuesResponse.HttpResponse = context.HttpResponse; listQueuesResponse.RequestId = context.StringValue("ListQueues.RequestId"); ListQueuesResponse.ListQueues_Data data = new ListQueuesResponse.ListQueues_Data(); data.NextToken = context.StringValue("ListQueues.Data.NextToken"); data.MaxResults = context.IntegerValue("ListQueues.Data.MaxResults"); List <ListQueuesResponse.ListQueues_Data.ListQueues_QueueVO> data_queues = new List <ListQueuesResponse.ListQueues_Data.ListQueues_QueueVO>(); for (int i = 0; i < context.Length("ListQueues.Data.Queues.Length"); i++) { ListQueuesResponse.ListQueues_Data.ListQueues_QueueVO queueVO = new ListQueuesResponse.ListQueues_Data.ListQueues_QueueVO(); queueVO.Name = context.StringValue("ListQueues.Data.Queues[" + i + "].Name"); queueVO.OwnerId = context.StringValue("ListQueues.Data.Queues[" + i + "].OwnerId"); queueVO.VHostName = context.StringValue("ListQueues.Data.Queues[" + i + "].VHostName"); queueVO.AutoDeleteState = context.BooleanValue("ListQueues.Data.Queues[" + i + "].AutoDeleteState"); queueVO.ExclusiveState = context.BooleanValue("ListQueues.Data.Queues[" + i + "].ExclusiveState"); queueVO.CreateTime = context.LongValue("ListQueues.Data.Queues[" + i + "].CreateTime"); queueVO.LastConsumeTime = context.LongValue("ListQueues.Data.Queues[" + i + "].LastConsumeTime"); queueVO.Attributes = context.StringValue("ListQueues.Data.Queues[" + i + "].Attributes"); data_queues.Add(queueVO); } data.Queues = data_queues; listQueuesResponse.Data = data; return(listQueuesResponse); }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonSQSConfig config = new AmazonSQSConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonSQSClient client = new AmazonSQSClient(creds, config); ListQueuesResponse resp = new ListQueuesResponse(); do { ListQueuesRequest req = new ListQueuesRequest { NextToken = resp.NextToken , MaxResults = maxItems }; resp = client.ListQueues(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.QueueUrls) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public static async Task<string?> FindQueueUrlByQueueName(string name) { using (var client = new AmazonSQSClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2)) { ListQueuesResponse response = await client.ListQueuesAsync(new ListQueuesRequest(name)); return response.QueueUrls?.FirstOrDefault(); } }
public static string ListSQSQueues() { AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient(); ListQueuesRequest sqsrequest = new ListQueuesRequest(); ListQueuesResponse sqsresponse = sqs.ListQueues(sqsrequest); ListQueuesResult sqsrst = sqsresponse.ListQueuesResult; return(sqsrst.ToString()); }
static async void ListQueues() { ListQueuesResponse response = await _sqsClient.ListQueuesAsync(""); foreach (var queueUrl in response.QueueUrls) { Console.WriteLine(queueUrl); } }
public async Task <string> ListQueues() { AmazonSQSClient client = new AmazonSQSClient(); ListQueuesResponse response = await client.ListQueuesAsync(string.Empty); var queueList = string.Join("#", response.QueueUrls.Select(x => x.Substring(x.LastIndexOf("/") + 1))); //"Compaints#inquairy" return(queueList); }
private async Task <bool> QueueExists(AmazonSQSClient client, string queueName) { var listQueuesRequest = new ListQueuesRequest { QueueNamePrefix = queueName }; ListQueuesResponse response = await client.ListQueuesAsync(listQueuesRequest); return(response.QueueUrls.Count == 0 ? false : true); }
// // Method to show a list of the existing queues private static async Task ShowQueues(IAmazonSQS sqsClient) { ListQueuesResponse responseList = await sqsClient.ListQueuesAsync(""); Console.WriteLine(); foreach (string qUrl in responseList.QueueUrls) { // Get and show all attributes. Could also get a subset. await ShowAllAttributes(sqsClient, qUrl); } }
public void ListQueueExample() { AmazonSQSClient client = new AmazonSQSClient(); ListQueuesResponse response = client.ListQueues(new ListQueuesRequest()); foreach (var queueUrl in response.QueueUrls) { Console.WriteLine(queueUrl); } }
public async Task <List <string> > GetQueueUrls() { ListQueuesResponse response = await sqsClient.ListQueuesAsync(new ListQueuesRequest()); var queues = new List <string>(); foreach (var queueUrl in response.QueueUrls) { queues.Add($"{queueUrl}"); } return(queues); }
public async Task ListQueueExample() { // Create service client using the SDK's default logic for determining AWS credentials and region to use. // For information configuring service clients checkout the .NET developer guide: https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html AmazonSQSClient client = new AmazonSQSClient(); ListQueuesResponse response = await client.ListQueuesAsync(new ListQueuesRequest()); foreach (var queueUrl in response.QueueUrls) { Console.WriteLine(queueUrl); } }
/// <summary> /// This method displays the Queue /// </summary> private void DisplayQueues() { ListQueuesResponse objqueuesResponseList = new ListQueuesResponse(); objqueuesResponseList = objClient.ListQueues(new ListQueuesRequest()); ListQueuesResult Result = objqueuesResponseList.ListQueuesResult; this.QueuesList.Visible = true; this.QueuesList.DataSource = Result.QueueUrl; this.QueuesList.DataBind(); }
public static string FindQueueUrlByQueueName(string name) { using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret)) { ListQueuesResponse response = client.ListQueues(new ListQueuesRequest(name)); foreach (string queueUrl in response.QueueUrls) { return(queueUrl); } } return(null); }
public ListQueuesResponse ListQueues(ListQueuesRequest request) { var urls = string.IsNullOrEmpty(request.QueueNamePrefix) ? queues.Keys : queues.Values .Where(q => q.QueueDefinition .QueueName.StartsWith(request.QueueNamePrefix, StringComparison.OrdinalIgnoreCase)) .Select(q => q.QueueDefinition.QueueUrl); var response = new ListQueuesResponse { QueueUrls = urls.ToList() }; return(response); }
private string TheQueueUrlFrom(ListQueuesResponse listQueuesResponse) { string queueUrl; if (listQueuesResponse.ListQueuesResult.QueueUrl.Count == 0) { var response = _client.CreateQueue(new CreateQueueRequest { QueueName = _config.SqsQueueName }); queueUrl = response.CreateQueueResult.QueueUrl; } else { queueUrl = listQueuesResponse.ListQueuesResult.QueueUrl[0]; } return(queueUrl); }
private static void FindOrCreateSQSQueue(AmazonSQS sqs) { //Confirming the queue exists ListQueuesRequest listQueuesRequest = new ListQueuesRequest(); ListQueuesResponse listQueuesResponse = sqs.ListQueues(listQueuesRequest); Console.WriteLine("Printing list of Amazon SQS queues.\n"); if (listQueuesResponse.IsSetListQueuesResult()) { ListQueuesResult listQueuesResult = listQueuesResponse.ListQueuesResult; foreach (String queueUrl in listQueuesResult.QueueUrl) { Console.WriteLine(" QueueUrl: {0}", queueUrl); } } Console.WriteLine(); }
public static ListQueuesResponse Unmarshall(UnmarshallerContext _ctx) { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(); listQueuesResponse.HttpResponse = _ctx.HttpResponse; listQueuesResponse.RequestId = _ctx.StringValue("ListQueues.RequestId"); List <ListQueuesResponse.ListQueues_QueueInfo> listQueuesResponse_queues = new List <ListQueuesResponse.ListQueues_QueueInfo>(); for (int i = 0; i < _ctx.Length("ListQueues.Queues.Length"); i++) { ListQueuesResponse.ListQueues_QueueInfo queueInfo = new ListQueuesResponse.ListQueues_QueueInfo(); queueInfo.QueueName = _ctx.StringValue("ListQueues.Queues[" + i + "].QueueName"); queueInfo.Type = _ctx.StringValue("ListQueues.Queues[" + i + "].Type"); queueInfo.ResourceGroupId = _ctx.StringValue("ListQueues.Queues[" + i + "].ResourceGroupId"); queueInfo.HostNamePrefix = _ctx.StringValue("ListQueues.Queues[" + i + "].HostNamePrefix"); queueInfo.HostNameSuffix = _ctx.StringValue("ListQueues.Queues[" + i + "].HostNameSuffix"); queueInfo.SpotStrategy = _ctx.StringValue("ListQueues.Queues[" + i + "].SpotStrategy"); queueInfo.ImageId = _ctx.StringValue("ListQueues.Queues[" + i + "].ImageId"); queueInfo.EnableAutoGrow = _ctx.BooleanValue("ListQueues.Queues[" + i + "].EnableAutoGrow"); List <string> queueInfo_computeInstanceType = new List <string>(); for (int j = 0; j < _ctx.Length("ListQueues.Queues[" + i + "].ComputeInstanceType.Length"); j++) { queueInfo_computeInstanceType.Add(_ctx.StringValue("ListQueues.Queues[" + i + "].ComputeInstanceType[" + j + "]")); } queueInfo.ComputeInstanceType = queueInfo_computeInstanceType; List <ListQueuesResponse.ListQueues_QueueInfo.ListQueues_Instance> queueInfo_spotInstanceTypes = new List <ListQueuesResponse.ListQueues_QueueInfo.ListQueues_Instance>(); for (int j = 0; j < _ctx.Length("ListQueues.Queues[" + i + "].SpotInstanceTypes.Length"); j++) { ListQueuesResponse.ListQueues_QueueInfo.ListQueues_Instance instance = new ListQueuesResponse.ListQueues_QueueInfo.ListQueues_Instance(); instance.InstanceType = _ctx.StringValue("ListQueues.Queues[" + i + "].SpotInstanceTypes[" + j + "].InstanceType"); instance.SpotPriceLimit = _ctx.FloatValue("ListQueues.Queues[" + i + "].SpotInstanceTypes[" + j + "].SpotPriceLimit"); queueInfo_spotInstanceTypes.Add(instance); } queueInfo.SpotInstanceTypes = queueInfo_spotInstanceTypes; listQueuesResponse_queues.Add(queueInfo); } listQueuesResponse.Queues = listQueuesResponse_queues; return(listQueuesResponse); }
public async Task SendSQSMessage(string content) { try { Console.WriteLine("==========================================="); Console.WriteLine("Getting Started with Amazon SQS"); Console.WriteLine("===========================================\n"); //Creating a queue //Console.WriteLine("Create a queue called MyQueue.\n"); //CreateQueueRequest sqsRequest = new CreateQueueRequest(); //sqsRequest.QueueName = "MyQueue"; //CreateQueueResponse createQueueResponse = await sqs.CreateQueueAsync(sqsRequest); //String myQueueUrl = "https://sqs.ap-southeast-1.amazonaws.com/783560535431/MyQueue1"; //myQueueUrl = createQueueResponse.QueueUrl; //Confirming the queue exists ListQueuesRequest listQueuesRequest = new ListQueuesRequest(); ListQueuesResponse listQueuesResponse = await sqs.ListQueuesAsync(listQueuesRequest); Console.WriteLine("Printing list of Amazon SQS queues.\n"); foreach (String queueUrl in listQueuesResponse.QueueUrls) { Console.WriteLine(" QueueUrl: {0}", queueUrl); } Console.WriteLine(); //Sending a message Console.WriteLine("Sending a message to MyQueue.\n"); SendMessageRequest sendMessageRequest = new SendMessageRequest(); sendMessageRequest.QueueUrl = myQueueUrl; //URL from initial queue creation sendMessageRequest.MessageBody = content; await sqs.SendMessageAsync(sendMessageRequest); } catch (AmazonSQSException ex) { Console.WriteLine("Caught Exception: " + ex.Message); Console.WriteLine("Response Status Code: " + ex.StatusCode); Console.WriteLine("Error Code: " + ex.ErrorCode); Console.WriteLine("Error Type: " + ex.ErrorType); Console.WriteLine("Request ID: " + ex.RequestId); } return; }
/// <summary> /// Core implementation for the ListQueues method. /// </summary> /// <param name="prefix">The queue prefix.</param> /// <param name="detailsIncluded">The details included.</param> /// <param name="currentToken">The continuation token.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param> /// <returns>A <see cref="TaskSequence"/> that lists the queues.</returns> private RESTCommand <ResultSegment <CloudQueue> > ListQueuesImpl(string prefix, int?maxResults, QueueListingDetails detailsIncluded, QueueRequestOptions options, QueueContinuationToken currentToken) { ListingContext listingContext = new ListingContext(prefix, maxResults) { Marker = currentToken != null ? currentToken.NextMarker : null }; RESTCommand <ResultSegment <CloudQueue> > getCmd = new RESTCommand <ResultSegment <CloudQueue> >(this.Credentials, this.StorageUri); options.ApplyToStorageCommand(getCmd); getCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(currentToken); getCmd.RetrieveResponseStream = true; getCmd.Handler = this.AuthenticationHandler; getCmd.BuildClient = HttpClientFactory.BuildHttpClient; getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.List(uri, serverTimeout, listingContext, detailsIncluded, cnt, ctx); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex); getCmd.PostProcessResponse = (cmd, resp, ctx) => { return(Task.Factory.StartNew(() => { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream); List <CloudQueue> queuesList = listQueuesResponse.Queues.Select(item => new CloudQueue(item.Metadata, item.Name, this)).ToList(); QueueContinuationToken continuationToken = null; if (listQueuesResponse.NextMarker != null) { continuationToken = new QueueContinuationToken() { NextMarker = listQueuesResponse.NextMarker, TargetLocation = cmd.CurrentResult.TargetLocation, }; } return new ResultSegment <CloudQueue>(queuesList) { ContinuationToken = continuationToken, }; })); }; return(getCmd); }
public bool DoesExist() { ListQueuesResponse response = Client.ListQueues(new ListQueuesRequest()); if (response.HttpStatusCode != HttpStatusCode.OK) { throw new MessagingException(String.Format( "An error occurred while attempting to determine whether the specified queue exists. AWS returned status code [{0}].", response.HttpStatusCode)); } if ((response.QueueUrls == null) || (response.QueueUrls.Count == 0)) { return(false); } return(response.QueueUrls.Any( q => (String.Compare(q, Endpoint.QueueUrl, StringComparison.InvariantCultureIgnoreCase) == 0))); }
/// <summary> /// Core implementation for the ListQueues method. /// </summary> /// <param name="prefix">The queue prefix.</param> /// <param name="detailsIncluded">The details included.</param> /// <param name="currentToken">The continuation token.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param> /// <returns>A <see cref="TaskSequence"/> that lists the queues.</returns> private RESTCommand<ResultSegment<CloudQueue>> ListQueuesImpl(string prefix, QueueListingDetails detailsIncluded, QueueContinuationToken currentToken, int? maxResults) { ListingContext listingContext = new ListingContext(prefix, maxResults) { Marker = currentToken != null ? currentToken.NextMarker : null }; RESTCommand<ResultSegment<CloudQueue>> getCmd = new RESTCommand<ResultSegment<CloudQueue>>(this.Credentials, this.BaseUri); getCmd.RetrieveResponseStream = true; getCmd.Handler = this.AuthenticationHandler; getCmd.BuildClient = HttpClientFactory.BuildHttpClient; getCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.List(cmd.Uri, cmd.ServerTimeoutInSeconds, listingContext, detailsIncluded, cnt, ctx); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx); getCmd.PostProcessResponse = (cmd, resp, ex, ctx) => { return Task.Factory.StartNew(() => { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream); List<CloudQueue> queuesList = new List<CloudQueue>( listQueuesResponse.Queues.Select(item => new CloudQueue(item.Name, this))); QueueContinuationToken continuationToken = null; if (listQueuesResponse.NextMarker != null) { continuationToken = new QueueContinuationToken() { NextMarker = listQueuesResponse.NextMarker, }; } return new ResultSegment<CloudQueue>(queuesList) { ContinuationToken = continuationToken, }; }); }; return getCmd; }
/// <summary> /// Core implementation for the ListQueues method. /// </summary> /// <param name="prefix">The queue prefix.</param> /// <param name="detailsIncluded">The details included.</param> /// <param name="currentToken">The continuation token.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param> /// <returns>A <see cref="TaskSequence"/> that lists the queues.</returns> private RESTCommand<ResultSegment<CloudQueue>> ListQueuesImpl(string prefix, int? maxResults, QueueListingDetails detailsIncluded, QueueRequestOptions options, QueueContinuationToken currentToken) { ListingContext listingContext = new ListingContext(prefix, maxResults) { Marker = currentToken != null ? currentToken.NextMarker : null }; RESTCommand<ResultSegment<CloudQueue>> getCmd = new RESTCommand<ResultSegment<CloudQueue>>(this.Credentials, this.StorageUri); options.ApplyToStorageCommand(getCmd); getCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(currentToken); getCmd.RetrieveResponseStream = true; getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.List(uri, serverTimeout, listingContext, detailsIncluded, cnt, ctx, this.GetCanonicalizer(), this.Credentials); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex); getCmd.PostProcessResponse = (cmd, resp, ctx) => { return Task.Factory.StartNew(() => { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream); List<CloudQueue> queuesList = listQueuesResponse.Queues.Select(item => new CloudQueue(item.Metadata, item.Name, this)).ToList(); QueueContinuationToken continuationToken = null; if (listQueuesResponse.NextMarker != null) { continuationToken = new QueueContinuationToken() { NextMarker = listQueuesResponse.NextMarker, TargetLocation = cmd.CurrentResult.TargetLocation, }; } return new ResultSegment<CloudQueue>(queuesList) { ContinuationToken = continuationToken, }; }); }; return getCmd; }
/// <summary> /// Core implementation of the ListQueues method. /// </summary> /// <param name="prefix">The queue name prefix.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param> /// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param> /// <param name="options">An object that specifies additional options for the request.</param> /// <param name="currentToken">The continuation token.</param> /// <returns>A <see cref="RESTCommand{T}"/> that lists the queues.</returns> private RESTCommand<ResultSegment<CloudQueue>> ListQueuesImpl(string prefix, int? maxResults, QueueListingDetails queueListingDetails, QueueRequestOptions options, QueueContinuationToken currentToken) { QueueListingContext listingContext = new QueueListingContext(prefix, maxResults, queueListingDetails) { Marker = currentToken != null ? currentToken.NextMarker : null }; RESTCommand<ResultSegment<CloudQueue>> getCmd = new RESTCommand<ResultSegment<CloudQueue>>(this.Credentials, this.BaseUri); getCmd.ApplyRequestOptions(options); getCmd.RetrieveResponseStream = true; getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.List(uri, serverTimeout, listingContext, queueListingDetails, ctx); getCmd.SignRequest = this.AuthenticationHandler.SignRequest; getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex); getCmd.PostProcessResponse = (cmd, resp, ctx) => { ListQueuesResponse listQueuesResponse = new ListQueuesResponse(cmd.ResponseStream); List<CloudQueue> queuesList = new List<CloudQueue>( listQueuesResponse.Queues.Select(item => new CloudQueue(item.Name, this))); QueueContinuationToken continuationToken = null; if (listQueuesResponse.NextMarker != null) { continuationToken = new QueueContinuationToken() { NextMarker = listQueuesResponse.NextMarker, }; } return new ResultSegment<CloudQueue>(queuesList) { ContinuationToken = continuationToken, }; }; return getCmd; }