/// <summary>
/// The DeleteMessage action unconditionally removes the specified message from the specified queue. Even if the message is locked by another reader due to the visibility timeout setting, it is still deleted from the queue.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">DeleteMessageRequest request</param>
public static void InvokeDeleteMessage(AmazonSQS service, DeleteMessageRequest request)
{
try
{
DeleteMessageResponse response = service.DeleteMessage(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" DeleteMessageResponse");
if (response.IsSetResponseMetadata())
{
Console.WriteLine(" ResponseMetadata");
ResponseMetadata responseMetadata = response.ResponseMetadata;
if (responseMetadata.IsSetRequestId())
{
Console.WriteLine(" RequestId");
Console.WriteLine(" {0}", responseMetadata.RequestId);
}
}
}
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("XML: " + ex.XML);
}
}
private void ReceiveMessage()
{
var receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = _handler.QueueUrl;
var receiveMessageResponse = _sqsClient.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult() && receiveMessageResponse.ReceiveMessageResult.Message.Count > 0)
{
Console.WriteLine("Received message");
var receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
Console.WriteLine("Message body: {0}", message.Body);
foreach (var handler in Container.GetAll <IServiceHandler>())
{
//TODO - need to refactor this, multiple handlers means multiple deserialization
if (handler.QueueName == _handler.QueueName && handler.IsRequestHandled(message))
{
Console.WriteLine("Passing request to handler: {0}", handler.GetType().Name);
handler.HandleRequest(message);
}
}
}
Console.WriteLine("Deleting message");
var messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle;
var deleteRequest = new DeleteMessageRequest()
.WithQueueUrl(_handler.QueueUrl)
.WithReceiptHandle(messageRecieptHandle);
_sqsClient.DeleteMessage(deleteRequest);
}
}
public ErrorTypes RemoveTask(object key)
{
ErrorTypes eResult = ErrorTypes.Unknown;
try
{
SQSDataKey oSQSDataKey = (SQSDataKey)key;
string strUrlQueue = GetQueueUrl(oSQSDataKey.m_oPriority);
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
DeleteMessageRequest oDeleteRequest = new DeleteMessageRequest();
oDeleteRequest.QueueUrl = strUrlQueue;
oDeleteRequest.ReceiptHandle = (string)oSQSDataKey.m_strReceiptHandle;
oSQSClient.DeleteMessage(oDeleteRequest);
eResult = ErrorTypes.NoError;
}
}
catch (AmazonSQSException)
{
}
catch
{
}
return(eResult);
}
private int ProcessMessage()
{
int numReceived = 0;
ActivityItems items = null;
try {
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
numReceived = receiveMessageResult.Message.Count;
foreach (Message message in receiveMessageResult.Message)
{
items = getActivityItems(message);
dispatchItems(items);
deleteMessageRequest.WithReceiptHandle(message.ReceiptHandle);
sqs.DeleteMessage(deleteMessageRequest);
}
}
} catch (Exception ex) {
log.Warn("An unknown error has occurred. Will retry message.", ex);
}
return(numReceived);
}
private void Delete(Message message)
{
var deleteRequest = new DeleteMessageRequest()
.WithReceiptHandle(message.ReceiptHandle)
.WithQueueUrl(_config.SqsQueueUrl);
_client.DeleteMessage(deleteRequest);
}
private void Delete_message(string receiptHandle)
{
var deleteRequest = new DeleteMessageRequest {
QueueUrl = _queueUrl,
ReceiptHandle = receiptHandle
};
_sqs.DeleteMessage(deleteRequest);
}
public static string Delete(string queue_url, string msg_id)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
DeleteMessageRequest d_msgreq = new DeleteMessageRequest();
d_msgreq.QueueUrl = queue_url;
d_msgreq.ReceiptHandle = msg_id;
DeleteMessageResponse d_msgres = sqs.DeleteMessage(d_msgreq);
return("Deleted Message \n" + d_msgres.ResponseMetadata.ToString());
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Deleting message {0} from Queue {1}", ReceiptHandle, QueueUrl);
var request = new DeleteMessageRequest { QueueUrl = QueueUrl, ReceiptHandle = ReceiptHandle };
client.DeleteMessage(request);
Logger.LogMessage(MessageImportance.Normal, "Deleted message {0} from queue {1}", ReceiptHandle, QueueUrl);
return true;
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Deleting message {0} from Queue {1}", ReceiptHandle, QueueUrl);
var request = new DeleteMessageRequest {
QueueUrl = QueueUrl, ReceiptHandle = ReceiptHandle
};
client.DeleteMessage(request);
Logger.LogMessage(MessageImportance.Normal, "Deleted message {0} from queue {1}", ReceiptHandle, QueueUrl);
return(true);
}
private void ReceiveMessage()
{
var receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = _queueUrl;
var receiveMessageResponse = _sqsClient.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult() && receiveMessageResponse.ReceiveMessageResult.Message.Count > 0)
{
Console.WriteLine("Received message at: {0}", DateTime.Now.ToLongTimeString());
var receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
Console.WriteLine("Message body: {0}", message.Body);
}
var response = receiveMessageResponse.FirstMessageAsResponse <QueryServiceResponse>();
if (response != null)
{
//fetch the data from the response store:
Console.WriteLine("Fetching data at: {0}", DateTime.Now.ToLongTimeString());
var responseItems = DataStore.Current.Fetch(response.StoreIdentifier, response.ItemKey);
var employees = new List <Employee>(responseItems.Count());
foreach (var responseItem in responseItems)
{
var employee = Serializer.Current.Deserialize(typeof(Employee), responseItem) as Employee;
Console.WriteLine("Adding employee - {0}", employee);
employees.Add(employee);
}
}
Console.WriteLine("Deleting message");
var messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle;
var deleteRequest = new DeleteMessageRequest()
.WithQueueUrl(_queueUrl)
.WithReceiptHandle(messageRecieptHandle);
_sqsClient.DeleteMessage(deleteRequest);
Console.WriteLine("Completed at: {0}", DateTime.Now.ToLongTimeString());
}
}
private static void ProcessQueue(string jobId, AmazonGlacier client, AWSArchiveRquest request)
{
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = queueUrl, MaxNumberOfMessages = 1
};
bool jobDone = false;
while (!jobDone)
{
var receiveMessageResponse = sqsClient.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.ReceiveMessageResult.Message.Count == 0)
{
Thread.Sleep(1000 * 60);
continue;
}
Amazon.SQS.Model.Message message = receiveMessageResponse.ReceiveMessageResult.Message[0];
Dictionary <string, string> outerLayer = JsonConvert.DeserializeObject <Dictionary <string, string> >(message.Body);
Dictionary <string, string> fields = JsonConvert.DeserializeObject <Dictionary <string, string> >(outerLayer["Message"]);
string statusCode = fields["StatusCode"] as string;
if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_SUCCEEDED, StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Downloading job output");
DownloadOutput(jobId, client, request); // This where we save job output to the specified file location.
}
else if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_FAILED, StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Job failed... cannot download the archive.");
}
jobDone = true;
sqsClient.DeleteMessage(new DeleteMessageRequest()
{
QueueUrl = queueUrl, ReceiptHandle = message.ReceiptHandle
});
}
}
private void ReceiveFromQueue()
{
int emptyReceiptCount = 0;
while (_serviceRunning)
{
try
{
var request = new ReceiveMessageRequest
{
QueueUrl = _queueUrl,
MaxNumberOfMessages = _serviceConfiguration.MaxNumberOfMessagesPerReceive,
WaitTimeSeconds = 20
};
Trace("Attmepting to receive message from queue '{0}'", _queueUrl);
ReceiveMessageResponse response;
try
{
response = _amazonSQS.ReceiveMessage(request);
}
catch (AmazonSQSException e)
{
//create the queue if the exception indicates the queue does not exist
if (e.Message.ToLowerInvariant().Contains("the specified queue does not exist"))
{
_createSQSQueueCommand.Invoke(new CreateSQSQueueRequest
{
QueueName = _queueUrl.GetQueueName()
});
}
emptyReceiptCount = 9; //equiv to 3 mins pause, the maximum we wait
Thread.Sleep(_requestThrottler.GetDelayMilliseconds(emptyReceiptCount));
continue;
}
if (!response.IsSetReceiveMessageResult() || response.ReceiveMessageResult.Message.Count == 0)
{
emptyReceiptCount++;
Trace("No message returned from queue '{0}', zero message count:={1}", _queueUrl, emptyReceiptCount);
//sleep for delay as specified by throttler (unless instructed to poll now)
int delay = _requestThrottler.GetDelayMilliseconds(emptyReceiptCount);
const int sleepPeriod = 100;
int sleepCount = 0;
while (sleepPeriod * ++sleepCount < delay)
{
if (_pollNow)
{
emptyReceiptCount = 0;
_pollNow = false;
break;
}
Thread.Sleep(sleepPeriod);
}
continue;
}
//reset the zero message count
emptyReceiptCount = 0;
Trace("Received {0} messages from queue '{1}'", response.ReceiveMessageResult.Message.Count, _queueUrl);
foreach (var message in response.ReceiveMessageResult.Message)
{
var envelope = GetEnvelope(message);
Trace("Receiving message for organisation:={0}", envelope.OrganisationId);
try
{
ObjectFactory.GetObject <IMessageProcessor>().Process(_serviceConfiguration, envelope);
_amazonSQS.DeleteMessage(new DeleteMessageRequest
{
QueueUrl = _queueUrl,
ReceiptHandle = envelope.ReceiptHandle
});
}
catch (Exception e)
{
var de = new ErrorditeDeleteSQSMessageException("Failed to delete message with receipt handle:={0}".FormatWith(envelope.ReceiptHandle), true, e);
if (e is ThreadAbortException)
{
continue;
}
Error(de);
ErrorditeClient.ReportException(de);
}
}
}
catch (Exception e)
{
if (e is ThreadAbortException)
{
continue;
}
Error(e);
ErrorditeClient.ReportException(e);
}
}
}
public static void Main(string[] args)
{
const string QUEUENAME = "MyQueue";
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
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 = QUEUENAME;
CreateQueueResponse createQueueResponse = sqs.CreateQueue(sqsRequest);
String myQueueUrl;
myQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
//Confirming the queue exists
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
ListQueuesResponse listQueuesResponse = sqs.ListQueues(listQueuesRequest);
var getQueueReq = new GetQueueUrlRequest();
getQueueReq.QueueName = "AppZwitschern";
var getQueueResp = sqs.GetQueueUrl(getQueueReq);
Console.WriteLine(":: Url={0}", getQueueResp.GetQueueUrlResult.QueueUrl);
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();
//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 = "This is my message text.";
sqs.SendMessage(sendMessageRequest);
//Receiving a message
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = myQueueUrl;
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
Console.WriteLine("Printing received message.\n");
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
Console.WriteLine(" Message");
if (message.IsSetMessageId())
{
Console.WriteLine(" MessageId: {0}", message.MessageId);
}
if (message.IsSetReceiptHandle())
{
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
}
if (message.IsSetMD5OfBody())
{
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
}
if (message.IsSetBody())
{
Console.WriteLine(" Body: {0}", message.Body);
}
foreach (Amazon.SQS.Model.Attribute attribute in message.Attribute)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName())
{
Console.WriteLine(" Name: {0}", attribute.Name);
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value: {0}", attribute.Value);
}
}
}
}
String messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle;
//Deleting a message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = myQueueUrl;
deleteRequest.ReceiptHandle = messageRecieptHandle;
sqs.DeleteMessage(deleteRequest);
}
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("XML: " + ex.XML);
}
Console.WriteLine("Press Enter to continue...");
Console.Read();
}
public AlertMessage GetNextMessage()
{
//Receiving a message
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = queueUrl;
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
Console.WriteLine("Printing received message.\n");
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
AlertMessage m = new AlertMessage();
Console.WriteLine(" Message");
if (message.IsSetMessageId())
{
Console.WriteLine(" MessageId: {0}", message.MessageId);
}
if (message.IsSetReceiptHandle())
{
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
}
if (message.IsSetMD5OfBody())
{
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
}
if (message.IsSetBody())
{
m.Body = message.Body;
Console.WriteLine(" Body: {0}", message.Body);
}
foreach (Amazon.SQS.Model.Attribute attribute in message.Attribute)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName() && attribute.Name == "Subject")
{
if (attribute.IsSetValue())
{
m.Subject = attribute.Value;
}
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value: {0}", attribute.Value);
}
}
// Deleting a message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = queueUrl;
deleteRequest.ReceiptHandle = message.ReceiptHandle;
sqs.DeleteMessage(deleteRequest);
return(m);
}
}
return(null);
}
