/// <summary>
/// This static method deletes a SQS queue. Once deleted, the queue and any messages on it will no longer be available.
/// </summary>
/// <param name="QueueName">The name of the queue to be deleted</param>
/// <param name="RegionEndpoint">Endpoint corresponding to the AWS region where the queue is located</param>
/// <param name="ErrorMessage">String that will receive the error message, if an error occurs</param>
/// <returns></returns>
public static bool DestroySQSQueue(string QueueName, RegionEndpoint RegionEndpoint, out string ErrorMessage, string AWSAccessKey = "", string AWSSecretKey = "")
{
bool result = false;
ErrorMessage = "";
IAmazonSQS queueClient;
if (!String.IsNullOrWhiteSpace(QueueName))
{
if (!String.IsNullOrEmpty(AWSAccessKey))
{
queueClient = AWSClientFactory.CreateAmazonSQSClient(AWSAccessKey, AWSSecretKey, RegionEndpoint);
}
else
{
queueClient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint);
}
try
{
// Load the queue URL
string url = queueClient.GetQueueUrl(QueueName).QueueUrl;
// Destroy the queue
queueClient.DeleteQueue(url);
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
}
}
return(result);
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
ErrorTypes eResult = ErrorTypes.Unknown;
string strUrlQueue = GetQueueUrl(oPriority);
try
{
oTask.VisibilityTimeout = m_oVisibilityTimeout;
string strData = TaskQueueData.SerializeToXml(oTask);
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
SendMessageRequest oSendMessageRequest = new SendMessageRequest();
oSendMessageRequest.QueueUrl = strUrlQueue;
oSendMessageRequest.MessageBody = strData;
oSQSClient.SendMessage(oSendMessageRequest);
eResult = ErrorTypes.NoError;
}
}
catch (AmazonSQSException)
{
eResult = ErrorTypes.TaskQueue;
}
catch
{
eResult = ErrorTypes.TaskQueue;
}
return(eResult);
}
/// <summary>
/// Register for publishing messages to SQS
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public IHaveFulfilledPublishRequirements WithSqsMessagePublisher<T>(Action<SqsWriteConfiguration> configBuilder) where T : Message
{
Log.Info("Adding SQS publisher");
var config = new SqsWriteConfiguration();
configBuilder(config);
var messageTypeName = typeof(T).Name.ToLower();
var queueName = string.IsNullOrWhiteSpace(config.QueueName)
? messageTypeName
: messageTypeName + "-" + config.QueueName;
_publishConfig.QueueName = queueName;
var publishEndpointProvider = CreatePublisherEndpointProvider(_publishConfig);
var locationName = publishEndpointProvider.GetLocationName();
var eventPublisher = new SqsPublisher(
locationName,
AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(Bus.Config.Region)),
config.RetryCountBeforeSendingToErrorQueue,
Bus.SerialisationRegister);
if (!eventPublisher.Exists())
eventPublisher.Create(config);
Bus.SerialisationRegister.AddSerialiser<T>(_serialisationFactory.GetSerialiser<T>());
Bus.AddMessagePublisher<T>(eventPublisher);
Log.Info(string.Format("Created SQS publisher - MessageName: {0}, QueueName: {1}", messageTypeName, locationName));
return this;
}
public void SetUp()
{
_client = AWSClientFactory.CreateAmazonSQSClient(Access_Key_ID, Secret_Access_Key);
//Ensure we create a test queue for the test cases. And remember to delete it in the teardown method.
bool hasCallbackArrived = false;
SQSResponseEventHandler <object, ResponseEventArgs> handler = null;
handler = delegate(object sender, ResponseEventArgs args)
{
ISQSResponse result = args.Response;
//Unhook from event.
_client.OnSQSResponse -= handler;
hasCallbackArrived = true;
};
//Hook to event
_client.OnSQSResponse += handler;
_client.CreateQueue(new CreateQueueRequest {
QueueName = _queue_UnitTesting, DefaultVisibilityTimeout = 3
});
EnqueueConditional(() => hasCallbackArrived);
EnqueueTestComplete();
}
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);
}
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 GetQueueAttributesResult GetTaskQueueAttr(Priority oPriority)
{
string strUrlQueue = GetQueueUrl(oPriority);
GetQueueAttributesResult oGetQueueAttributesResult = null;
try
{
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
GetQueueAttributesRequest oGetQueueAttributesRequest = new GetQueueAttributesRequest();
oGetQueueAttributesRequest.QueueUrl = strUrlQueue;
GetQueueAttributesResponse oGetQueueAttributesResponse = oSQSClient.GetQueueAttributes(oGetQueueAttributesRequest);
if (oGetQueueAttributesResponse.IsSetGetQueueAttributesResult())
{
oGetQueueAttributesResult = oGetQueueAttributesResponse.GetQueueAttributesResult;
}
}
}
catch (AmazonSQSException)
{
}
catch
{
}
return(oGetQueueAttributesResult);
}
private static List <string> GetAllQueues(RegionEndpoint regionEndpoint, string queueName)
{
var client = AWSClientFactory.CreateAmazonSQSClient(regionEndpoint);
var topics = client.ListQueues(new ListQueuesRequest());
return(topics.QueueUrls.Where(x => x.IndexOf(queueName, StringComparison.InvariantCultureIgnoreCase) >= 0).ToList());
}
public SqsQueueByName VerifyOrCreateQueue(string region, IMessageSerialisationRegister serialisationRegister, SqsConfiguration queueConfig)
{
var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region));
var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region));
var queue = new SqsQueueByName(queueConfig.QueueName, sqsclient, queueConfig.RetryCountBeforeSendingToErrorQueue);
var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister);
queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdated(queueConfig);
if (!eventTopic.Exists())
{
eventTopic.Create();
}
if (!eventTopic.IsSubscribed(queue))
{
eventTopic.Subscribe(queue);
}
if (!queue.HasPermission(eventTopic))
{
queue.AddPermission(eventTopic);
}
return(queue);
}
public ObjectQueue(string awsAccessKey, string awsSecretKey, string queueName)
{
this.client = AWSClientFactory.CreateAmazonSQSClient(
awsAccessKey,
awsSecretKey
);
EnsureQueueExists();
var cqr = new CreateQueueRequest();
cqr.QueueName = queueName;
try
{
var response = this.client.CreateQueue(cqr);
if (!string.IsNullOrEmpty(response.QueueUrl))
{
this.queueUrl = response.QueueUrl;
}
else
{
throw new QueueException("Queue could not be created.");
}
}
catch (Exception ex)
{
throw new QueueException("Queue could not be created.", ex);
}
}
public bool Execute()
{
Console.WriteLine("Moving {0} messages from {1} to {2}", Count, SourceQueueName, DestinationQueueName);
var client = AWSClientFactory.CreateAmazonSQSClient(_configuration.AWSAccessKey, _configuration.AWSSecretKey, RegionEndpoint.GetBySystemName(_configuration.Region));
var sourceQueue = new SqsQueueByName(SourceQueueName, client, JustSayingConstants.DEFAULT_HANDLER_RETRY_COUNT);
var destinationQueue = new SqsQueueByName(DestinationQueueName, client, JustSayingConstants.DEFAULT_HANDLER_RETRY_COUNT);
var messages = PopMessagesFromSourceQueue(sourceQueue);
var receiptHandles = messages.ToDictionary(m => m.MessageId, m => m.ReceiptHandle);
var sendResponse = destinationQueue.Client.SendMessageBatch(new SendMessageBatchRequest()
{
QueueUrl = destinationQueue.Url,
Entries = messages.Select(x => new SendMessageBatchRequestEntry {
Id = x.MessageId, MessageBody = x.Body
}).ToList()
});
var deleteResponse = sourceQueue.Client.DeleteMessageBatch(new DeleteMessageBatchRequest
{
QueueUrl = sourceQueue.Url,
Entries = sendResponse.Successful.Select(x => new DeleteMessageBatchRequestEntry
{
Id = x.Id,
ReceiptHandle = receiptHandles[x.Id]
}).ToList()
});
Console.WriteLine("Moved {0} messages from {1} to {2}", sendResponse.Successful.Count, SourceQueueName, DestinationQueueName);
return(true);
}
private static void DeleteQueue(RegionEndpoint regionEndpoint, string queueUrl)
{
var client = AWSClientFactory.CreateAmazonSQSClient(regionEndpoint);
client.DeleteQueue(new DeleteQueueRequest {
QueueUrl = queueUrl
});
}
public SqsQueueByName EnsureQueueExists(string region, SqsReadConfiguration queueConfig)
{
var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region));
var queue = new SqsQueueByName(queueConfig.QueueName, sqsclient, queueConfig.RetryCountBeforeSendingToErrorQueue);
queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdated(queueConfig);
return(queue);
}
/// <summary>
/// Creates SQS client.
/// </summary>
/// <returns>SQS client.</returns>
private IAmazonSQS CreateClient()
{
return(AWSClientFactory.CreateAmazonSQSClient(
"AKIAJYOMMF624CPAWJVQ",
"3gwWov3ViX/UTQAGFjUXglxdpcz9oNIFi+GFKLHf",
RegionEndpoint.USWest2
));
}
public static string ListSQSQueues()
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
ListQueuesRequest sqsrequest = new ListQueuesRequest();
ListQueuesResponse sqsresponse = sqs.ListQueues(sqsrequest);
ListQueuesResult sqsrst = sqsresponse.ListQueuesResult;
return(sqsrst.ToString());
}
public AmazonSqsFacade(AmazonAccountSettings amazonAccountSettings)
{
amazonAccountSettings.Requires("amazonAccountSettings").IsNotNull();
amazonSqsFactory = () =>
AWSClientFactory.CreateAmazonSQSClient(amazonAccountSettings.AccessKey,
amazonAccountSettings.SecretKey,
amazonAccountSettings.RegionEndPoint.
ToRegionEndpoint());
}
private static void EnsureSqs()
{
if (sqs == null)
{
lock (lockObject)
{
sqs = AWSClientFactory.CreateAmazonSQSClient();
}
}
}
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 bool QueueHasPolicyForTopic(RegionEndpoint regionEndpoint, Topic topic, string queueUrl)
{
var client = AWSClientFactory.CreateAmazonSQSClient(regionEndpoint);
var policy = client.GetQueueAttributes(new GetQueueAttributesRequest {
QueueUrl = queueUrl, AttributeNames = new List <string> {
"Policy"
}
}).Policy;
return(policy.Contains(topic.TopicArn));
}
public static string Send(string queue_url, string msg)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
SendMessageRequest msgreq = new SendMessageRequest();
msgreq.QueueUrl = queue_url;
msgreq.MessageBody = msg;
SendMessageResponse msgres = sqs.SendMessage(msgreq);
SendMessageResult msgrst = msgres.SendMessageResult;
return(msgrst.ToString());
}
private AwsClient()
{
_amazonSqs = AWSClientFactory.CreateAmazonSQSClient();
QueueName = "TestQueue2";
//Creating a queue
var sqsRequest = new CreateQueueRequest {
QueueName = QueueName
};
var createQueueResponse = _amazonSqs.CreateQueue(sqsRequest);
_queueUrl = createQueueResponse.QueueUrl;
}
/// <summary>
/// The method opens the queue
/// </summary>
public bool OpenQueue(string queuename, int maxnumberofmessages, RegionEndpoint regionendpoint, String AWSAccessKey = "", String AWSSecretKey = "", bool useRabbitMQ = false, RabbitMQParameters rabbitParameters = null)
{
ClearErrorInfo();
IsValid = false;
UseRabbitMQ = useRabbitMQ;
if (UseRabbitMQ)
{
IsValid = OpenRabbitQueue(queuename, maxnumberofmessages, rabbitParameters);
}
else
{
if (!string.IsNullOrWhiteSpace(queuename))
{
if (!String.IsNullOrEmpty(AWSAccessKey))
{
queue = AWSClientFactory.CreateAmazonSQSClient(AWSAccessKey, AWSSecretKey, regionendpoint);
}
else
{
queue = AWSClientFactory.CreateAmazonSQSClient(regionendpoint);
}
try
{
// Get queue url
GetQueueUrlRequest sqsRequest = new GetQueueUrlRequest();
sqsRequest.QueueName = queuename;
queueurl = queue.GetQueueUrl(sqsRequest);
// Format receive messages request
rcvMessageRequest = new ReceiveMessageRequest();
rcvMessageRequest.QueueUrl = queueurl.QueueUrl;
rcvMessageRequest.MaxNumberOfMessages = maxnumberofmessages;
// Format the delete messages request
delMessageRequest = new DeleteMessageRequest();
delMessageRequest.QueueUrl = queueurl.QueueUrl;
IsValid = true;
}
catch (Exception ex)
{
ErrorCode = e_Exception;
ErrorMessage = ex.Message;
}
}
}
return(IsValid);
}
/// <summary>
/// Instantiates the Poller.
/// </summary>
/// <param name="props">
/// A <see cref="MessageGearsProperties"/>
/// </param>
/// <param name="listener">
/// A <see cref="MessageGearsListener"/>
/// </param>
/// <param name="myAwsAccountKey">
/// You AWS Account Key
/// </param>
/// <param name="myAwsSecretKey">
/// Your AWS Secret Key
/// </param>
public MessageGearsAwsQueuePoller(MessageGearsAwsProperties props, MessageGearsListener listener)
{
this.props = props;
this.emptyQueueDelayMillis = props.EmptyQueuePollingDelaySecs * 1000;
this.listener = listener;
AmazonSQSConfig config = new AmazonSQSConfig().WithMaxErrorRetry(props.SQSMaxErrorRetry);
this.sqs = AWSClientFactory.CreateAmazonSQSClient(props.MyAWSAccountKey, props.MyAWSSecretKey, config);
this.receiveMessageRequest = new ReceiveMessageRequest()
.WithQueueUrl(props.MyAWSEventQueueUrl)
.WithMaxNumberOfMessages(props.SQSMaxBatchSize)
.WithAttributeName("ApproximateReceiveCount")
.WithVisibilityTimeout(props.SQSVisibilityTimeoutSecs);
this.deleteMessageRequest = new DeleteMessageRequest().WithQueueUrl(props.MyAWSEventQueueUrl);
}
/// <summary>
/// The method opens the queue
/// </summary>
public bool OpenQueue(string queuename, int maxnumberofmessages, String AWSAccessKey, String AWSSecretKey)
{
ClearErrorInfo();
IsValid = false;
if (!string.IsNullOrWhiteSpace(queuename))
{
// Checking for the need to use provided credentials instead of reading from app.Config
if (!String.IsNullOrWhiteSpace(AWSSecretKey) && !String.IsNullOrWhiteSpace(AWSSecretKey))
{
AWSCredentials awsCredentials = new BasicAWSCredentials(AWSAccessKey, AWSSecretKey);
queue = AWSClientFactory.CreateAmazonSQSClient(awsCredentials, RegionEndpoint.USEast1);
}
else
{
queue = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.USEast1);
}
try
{
// Get queue url
GetQueueUrlRequest sqsRequest = new GetQueueUrlRequest();
sqsRequest.QueueName = queuename;
queueurl = queue.GetQueueUrl(sqsRequest);
// Format receive messages request
rcvMessageRequest = new ReceiveMessageRequest();
rcvMessageRequest.QueueUrl = queueurl.QueueUrl;
rcvMessageRequest.MaxNumberOfMessages = maxnumberofmessages;
// Format the delete messages request
delMessageRequest = new DeleteMessageRequest();
delMessageRequest.QueueUrl = queueurl.QueueUrl;
IsValid = true;
}
catch (Exception ex)
{
ErrorCode = e_Exception;
ErrorMessage = ex.Message;
}
}
return(IsValid);
}
public static int Count(string queue_url)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
GetQueueAttributesRequest gqreq = new GetQueueAttributesRequest();
gqreq.QueueUrl = queue_url;
List <string> attr = new List <string>();
attr.Add("All");
gqreq.AttributeName = attr;
GetQueueAttributesResponse gqres = sqs.GetQueueAttributes(gqreq);
GetQueueAttributesResult gqrst = gqres.GetQueueAttributesResult;
//Console.WriteLine("Invisible Messages:" + gqrst.ApproximateNumberOfMessagesNotVisible.ToString());
//Console.WriteLine("Messages:" + gqrst.ApproximateNumberOfMessages);
return(gqrst.ApproximateNumberOfMessages);
}
protected bool IsQueueSubscribedToTopic(RegionEndpoint regionEndpoint, Topic topic, string queueUrl)
{
var request = new GetQueueAttributesRequest {
QueueUrl = queueUrl, AttributeNames = new List <string> {
"QueueArn"
}
};
var sqsclient = AWSClientFactory.CreateAmazonSQSClient(regionEndpoint);
var queueArn = sqsclient.GetQueueAttributes(request).QueueARN;
var client = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(regionEndpoint);
var subscriptions = client.ListSubscriptionsByTopic(new ListSubscriptionsByTopicRequest(topic.TopicArn)).Subscriptions;
return(subscriptions.Any(x => !string.IsNullOrEmpty(x.SubscriptionArn) && x.Endpoint == queueArn));
}
public static Message Get(string queue_url)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
ReceiveMessageRequest r_msgreq = new ReceiveMessageRequest();
r_msgreq.MaxNumberOfMessages = 1;
r_msgreq.QueueUrl = queue_url;
Decimal Vis_Timeout = System.Convert.ToDecimal(ConfigurationManager.AppSettings["SQS_Visibility"]);
r_msgreq.VisibilityTimeout = Vis_Timeout;
ReceiveMessageResponse r_msgres = sqs.ReceiveMessage(r_msgreq);
//ChangeMessageVisibilityRequest chg_message_vis = new ChangeMessageVisibilityRequest();
//chg_message_vis.QueueUrl = ConfigurationManager.AppSettings["SQSUrl"];
//chg_message_vis.ReceiptHandle = r_msgres.ResponseMetadata.RequestId
ReceiveMessageResult r_msgrst = r_msgres.ReceiveMessageResult;
Message msg = r_msgrst.Message.FirstOrDefault();
return(msg);
}
protected SqsClient(IAwsConfiguration awsConfiguration)
{
if (awsConfiguration == null)
{
throw new ArgumentNullException("awsConfiguration");
}
awsConfiguration.Validate();
try
{
Client = AWSClientFactory.CreateAmazonSQSClient(awsConfiguration.AccessKey, awsConfiguration.SecretKey);
}
catch (Exception ex)
{
throw new MessagingException(
"An error occurred while attempting to access SQS. See inner exception for more details.",
ex);
}
}
public void Arrange()
{
tempQueueName = "Test_QUEUE_1";
_config = Configure.With()
.StructureMapBuilder()
.HandlersAreInAssemblyContainingType <TestEvent>()
.AmazonPublisher();
_config
.AwsAccessKeyId(awsKey)
.AwsSecretKey(secret)
.TopicArn(topicArn)
.QueueName(tempQueueName)
.EventsAreInAssemblyContainingType <TestEvent>();
_publisher = new AmazonPublisher(_config);
_amazonClient = AWSClientFactory.CreateAmazonSQSClient(awsKey, secret);
_snsClient = AWSClientFactory.CreateAmazonSNSClient(awsKey, secret);
}
private TaskQueueData GetTask(Priority oPriority)
{
string strUrlQueue = GetQueueUrl(oPriority);
TaskQueueData oData = null;
try
{
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
ReceiveMessageRequest oReceiveMessageRequest = new ReceiveMessageRequest();
oReceiveMessageRequest.QueueUrl = strUrlQueue;
oReceiveMessageRequest.MaxNumberOfMessages = 1;
ReceiveMessageResponse oReceiveMessageResponse = oSQSClient.ReceiveMessage(oReceiveMessageRequest);
if (oReceiveMessageResponse.IsSetReceiveMessageResult())
{
ReceiveMessageResult oReceiveMessageResult = oReceiveMessageResponse.ReceiveMessageResult;
foreach (Message oMessage in oReceiveMessageResult.Message)
{
oData = TaskQueueData.DeserializeFromXml(oMessage.Body);
SQSDataKey oSQSDataKey = new SQSDataKey();
oSQSDataKey.m_oPriority = oPriority;
oSQSDataKey.m_strReceiptHandle = oMessage.ReceiptHandle;
oData.m_oDataKey = oSQSDataKey;
break;
}
}
}
}
catch (AmazonSQSException)
{
}
catch
{
}
return(oData);
}