public override T Unmarshall <T>(IResponseContext context)
{
try
{
var response = new GetQueueUrlResponse();
ResultUnmarshall(context, response);
var xmlRootNode = GetXmlElement(context.ContentStream);
response.QueueUrl = xmlRootNode.SelectSingleNode("GetQueueUrlResult/QueueUrl")?.InnerText;
response.ResponseMetadata.RequestId = xmlRootNode.SelectSingleNode("ResponseMetadata/RequestId")?.InnerText;
return(response as T);
}
catch (Exception ex)
{
throw ErrorUnmarshall(ex.Message, ex, context.StatusCode);
}
}
public async void GetQueueUrlWithDegradation_Test()
{
var request = new GetQueueUrlRequest();
var message = new GetQueueUrlResponse
{
HttpStatusCode = HttpStatusCode.OK
};
amazonSQSMock
.Setup(e => e.GetQueueUrlAsync(request, cancellationToken))
.ReturnsAsync(message);
var response = await target.GetQueueUrlWithDegradation(request, cancellationToken);
response.Should().NotBeNull();
response.Should().Be(message);
amazonSQSMock.VerifyAll();
}
public async Task <GetQueueUrlResponse> GetQueueUrlWithDegradation(GetQueueUrlRequest request, CancellationToken cancellationToken)
{
var failedAttemptCount = 0;
Exception lastException = null;
GetQueueUrlResponse response = null;
while (failedAttemptCount < 10 && !cancellationToken.IsCancellationRequested)
{
var delayTime = SuspendTimeInMilliseconds(failedAttemptCount);
if (delayTime > 0)
{
await Task.Delay(delayTime, cancellationToken);
}
try
{
response = await sqsClient.GetQueueUrlAsync(request, cancellationToken);
if (response?.HttpStatusCode == HttpStatusCode.OK)
{
return(response);
}
lastException = new HttpRequestException($"Got HttpStatusCode {response?.HttpStatusCode} by request");
failedAttemptCount++;
}
catch (AmazonSQSException ex)
{
lastException = ex;
failedAttemptCount++;
}
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
throw new GetResponseFailedException(lastException);
}
public static void Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true)
.Build();
Console.Title = configuration["ApplicationName"];
var profile = configuration["AWSProfile"];
var credentials = new StoredProfileAWSCredentials(profile);
var sqsClient = new AmazonSQSClient(credentials, RegionEndpoint.EUWest1);
// Create queue if not exist
GetQueueUrlResponse queue = sqsClient.GetQueueUrlAsync("BFQueue").Result;
var receiveMessageRequest = new ReceiveMessageRequest
{
QueueUrl = queue.QueueUrl,
WaitTimeSeconds = 10,
VisibilityTimeout = 10
};
while (true)
{
Console.WriteLine("Polling Queue");
var messagesResponse = sqsClient.ReceiveMessageAsync(receiveMessageRequest).Result;
foreach (var message in messagesResponse.Messages)
{
Console.WriteLine($"Message: { message.Body }");
var deleteMessageRequest = new DeleteMessageRequest(queue.QueueUrl, message.ReceiptHandle);
DeleteMessageResponse result = sqsClient.DeleteMessageAsync(deleteMessageRequest).Result;
}
}
}
private string ValidateQueue(string QueueName, bool createIfNotExists)
{
GetQueueUrlResponse s = null;
string result = string.Empty;
try
{
GetQueueUrlRequest urlQueueRequest = new GetQueueUrlRequest
{
QueueName = QueueName
};
try
{
s = amazonSQSClient.GetQueueUrlAsync(urlQueueRequest).Result;
}
catch (System.AggregateException)
{
//QueueNotExists
return(createQueue(QueueName));
}
if (s.QueueUrl.Any())
{
if (!queuesDic.TryAdd(QueueName, s.QueueUrl))
{
throw new Exception("Fail to Put Queue on Dic");
}
return(s.QueueUrl);
}
else
{
return(createQueue(QueueName));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
GetQueueUrlResponse response = new GetQueueUrlResponse();
while (context.Read())
{
if (context.IsStartElement)
{
if (context.TestExpression("GetQueueUrlResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.GetInstance().Unmarshall(context);
}
}
}
return(response);
}
public SetQueueAttributesResponse AttachDeadLetterQueue(string queueName, string queueNameDeadLetter, int maxRetries)
{
GetQueueUrlResponse queueURL = SQSClient.GetQueueUrl(queueName);
GetQueueUrlResponse queueURLDeadLetter = SQSClient.GetQueueUrl(queueNameDeadLetter);
// Next, we need to get the the ARN (Amazon Resource Name) of our dead
// letter queue so we can configure our main queue to deliver messages to it.
IDictionary attributes = SQSClient.GetQueueAttributes(new GetQueueAttributesRequest()
{
QueueUrl = queueURLDeadLetter.QueueUrl,
AttributeNames = new List <string>()
{
"QueueArn"
}
}).Attributes;
string dlqArn = (string)attributes["QueueArn"];
// The last step is setting a RedrivePolicy on our main queue to configure
// it to deliver messages to our dead letter queue if they haven't been
// successfully processed after five attempts.
string redrivePolicy = string.Format(
"{{\"maxReceiveCount\":\"{0}\", \"deadLetterTargetArn\":\"{1}\"}}",
maxRetries, dlqArn);
SetQueueAttributesResponse awsSQAR = SQSClient.SetQueueAttributes(new SetQueueAttributesRequest()
{
QueueUrl = queueURL.QueueUrl,
Attributes = new Dictionary <string, string>()
{
{ "RedrivePolicy", redrivePolicy }
}
});
return(awsSQAR);
}
static void Main(string[] args)
{
var appSettings = ConfigurationManager.AppSettings;
string sqsQueueName = appSettings["AWSQueue" + args[0].ToString().ToUpper().Trim()].ToString();
string sqsDLQueueName = appSettings["AWSDeadLetterQueue" + args[0].ToString().ToUpper().Trim()].ToString();
int maxSQSRetries = Convert.ToInt32(appSettings["MaxSQSRetries"].ToString());
string urlWMIService = appSettings["WMIServiceURL" + args[0].ToString().ToUpper().Trim()].ToString();
int batchSize = Convert.ToInt32(appSettings["BatchSize"].ToString());
IAmazonSQS sqsClient = new AmazonSQSClient();
IAWSSQSWrapper awsSQSWrapper = new AWSSQSWrapper(sqsClient);
//Display our current list of Amazon SQS queues
Console.WriteLine("Checking to see if AWS environment is available...\n");
ListQueuesResponse lqr = awsSQSWrapper.LisQueues();
bool queueExists = false;
bool dlqueueExists = false;
if (lqr.QueueUrls != null)
{
foreach (String queueUrl in lqr.QueueUrls)
{
if (queueUrl.ToUpper().Trim().EndsWith(sqsQueueName.ToUpper().Trim()))
{
queueExists = true;
Console.WriteLine("Queue Exists: {0}", queueUrl);
GetQueueAttributesResponse gQAR = awsSQSWrapper.GetQueueAttributes(queueUrl);
if (gQAR.Attributes != null)
{
foreach (KeyValuePair <string, string> tmp in gQAR.Attributes)
{
Console.WriteLine(" Attribute: {0} Value:{1}", tmp.Key.ToString(), tmp.Value.ToString());
}
}
}
if (queueUrl.ToUpper().Trim().EndsWith(sqsDLQueueName.ToUpper().Trim()))
{
dlqueueExists = true;
Console.WriteLine("Queue Exists: {0}", queueUrl);
GetQueueAttributesResponse gQAR = awsSQSWrapper.GetQueueAttributes(queueUrl);
if (gQAR.Attributes != null)
{
foreach (KeyValuePair <string, string> tmp in gQAR.Attributes)
{
Console.WriteLine(" Attribute: {0} Value:{1}", tmp.Key.ToString(), tmp.Value.ToString());
}
}
}
}
}
if (!dlqueueExists)
{
Console.WriteLine("The dead letter queue was missing, let's build it...\n");
awsSQSWrapper.CreateQueue(sqsDLQueueName, false);
Console.WriteLine("Dead Letter Queue built successfuly.\n");
Console.WriteLine("Press any key...");
Console.ReadKey();
}
if (!queueExists)
{
Console.WriteLine("Message queue was missing, let's build it...\n");
awsSQSWrapper.CreateQueue(sqsQueueName, false);
awsSQSWrapper.AttachDeadLetterQueue(sqsQueueName, sqsDLQueueName, maxSQSRetries);
Console.WriteLine("Message queue built successfuly.\n");
Console.WriteLine("Press any key...");
Console.ReadKey();
}
Console.WriteLine("AWS environment ready.\n");
Console.WriteLine("Press any key...");
Console.ReadKey();
GetQueueUrlResponse awsGQUR = sqsClient.GetQueueUrl(sqsQueueName);
Console.WriteLine("Creating test messages...");
CreateMessages(awsSQSWrapper, awsGQUR.QueueUrl.ToString(), 10);
Console.WriteLine("Creating test messages complete.");
Console.WriteLine("Press any key...");
Console.ReadKey();
string response = GetREST();
Console.WriteLine("GET Received: {0}", response);
Console.WriteLine("Press any key...");
Console.ReadKey();
//string awsMessage = GetMessage(awsSQSWrapper, awsGQUR.QueueUrl);
bool continueReceiving = true;
while (continueReceiving)
{
ReceiveMessageResponse awsRMR = awsSQSWrapper.ReceiveMessage(awsGQUR.QueueUrl);
if (awsRMR.Messages.Count > 0)
{
response = PostREST(awsRMR.Messages[0].Body.ToString());
Console.WriteLine("POST Returned: {0}", response);
DeleteMessageResponse awsDMR = awsSQSWrapper.DeleteMessage(awsGQUR.QueueUrl, awsRMR.Messages[0].ReceiptHandle.ToString());
Console.WriteLine("Message Deleted: {0}", awsRMR.Messages[0].ReceiptHandle.ToString());
}
else
{
continueReceiving = false;
}
}
Console.WriteLine("\n\nAll messages sent.");
Console.WriteLine("Press any key...");
Console.ReadKey();
}
protected void GetQueueDetailsFromAws()
{
Logger.LogDebug("Getting SQS queue URL...");
_queueDetails = _sqsClient.GetQueueUrlAsync(_queueName).Result;
Logger.LogDebug($"SQS queue URL retrieved: {_queueDetails.QueueUrl}");
}
