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