protected override bool Execute(AwsClientDetails clientDetails)
{
using (AmazonSQS client = GetClient(clientDetails))
{
return(Execute(client));
}
}
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();
}
protected override bool Execute(AmazonSQS client)
{
Log.LogMessage(MessageImportance.Normal, "Granting SendMessage rights to SQS Queue at {0}", QueueUrl);
string queueArn = GetQueueArn(client, QueueUrl);
Log.LogMessage(MessageImportance.Low, "Queue {0} Arn: {1}", QueueUrl, queueArn);
var request = new SetQueueAttributesRequest {
QueueUrl = QueueUrl
};
var attribute = new Attribute {
Name = "Policy", Value = ConstructPolicy(queueArn, SourceArn)
};
request.Attribute = new List <Attribute> {
attribute
};
client.SetQueueAttributes(request);
Logger.LogMessage(MessageImportance.Normal, "Granted rights for source {0} to SendMessage to SQS at {1}", SourceArn, QueueUrl);
return(true);
}
/// <summary>
/// Used to create a new instance of the MessageGears client.
/// </summary>
/// <param name="props">
/// Contains the credentials needed to access MessageGears, Amazon S3, and Amazon SQS.<see cref="MessageGearsProperties"/>
/// </param>
public MessageGearsAwsClient(MessageGearsAwsProperties props)
{
this.properties = props;
this.sqs = new AmazonSQSClient(properties.MyAWSAccountKey, properties.MyAWSSecretKey);
this.s3 = new AmazonS3Client(properties.MyAWSAccountKey, properties.MyAWSSecretKey);
log.Info("MessageGears AWS client initialized");
}
private static void SendMessage(SendMessageRequest request, AmazonSQS sqs, ServiceRequest serviceRequest)
{
Console.WriteLine("Sending message, body: {0}, at: {1}", request.MessageBody, DateTime.Now.ToLongTimeString());
var response = sqs.SendMessage(request);
Console.WriteLine("Sent message, id: {0}, at: {1}", response.SendMessageResult.MessageId, DateTime.Now.ToLongTimeString());
}
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);
}
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);
}
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);
}
/// <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);
}
}
public ResponseSender()
{
// initialize Amazon SQSClient
AmazonSQSConfig sqsConfig = new AmazonSQSConfig();
sqsConfig.ServiceURL = ConfigurationManager.AppSettings["SQSServiceURL"].ToString();
m_sqsClient = AWSClientFactory.CreateAmazonSQSClient(sqsConfig);
}
/// <summary>
/// Used to create a new instance of the MessageGears client.
/// </summary>
/// <param name="props">
/// Contains the credentials needed to access MessageGears, Amazon S3, and Amazon SQS.<see cref="MessageGearsProperties"/>
/// </param>
public MessageGearsAwsClient(MessageGearsAwsProperties props)
{
this.properties = props;
this.sqs = new AmazonSQSClient(properties.MyAWSAccountKey, properties.MyAWSSecretKey);
this.s3 = new AmazonS3Client(properties.MyAWSAccountKey, properties.MyAWSSecretKey);
log.Info("MessageGears AWS client initialized");
}
public MonitoringController(IGetMessageEnvelopes getMessageEnvelopes,
IPagingViewModelGenerator pagingViewModelGenerator,
AmazonSQS amazonSqs)
{
_getMessageEnvelopes = getMessageEnvelopes;
_pagingViewModelGenerator = pagingViewModelGenerator;
_amazonSQS = amazonSqs;
}
public AwsSqsHost(AmazonSQS sqsClient, IDictionary<string, string> queueUrls, int retryCount = DefaultRetryCount, TimeSpan? requestTimeOut = null)
: base(null, retryCount, requestTimeOut)
{
if (sqsClient == null) throw new ArgumentNullException("sqsClient");
if (queueUrls == null) throw new ArgumentNullException("queueUrls");
client = sqsClient;
QueueUrls = queueUrls;
}
public SqsClient(AmazonSQS client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
this.Client = client;
}
public static string ListSQSQueues()
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
ListQueuesRequest sqsrequest = new ListQueuesRequest();
ListQueuesResponse sqsresponse = sqs.ListQueues(sqsrequest);
ListQueuesResult sqsrst = sqsresponse.ListQueuesResult;
return(sqsrst.ToString());
}
protected internal virtual AmazonSQS GetClient()
{
var config = new AmazonSQSConfig
{
ServiceURL = _serviceUrl,
};
return(_client ?? (_client = Amazon.AWSClientFactory.CreateAmazonSQSClient(_accessKey, _secretKey, config)));
}
public SqsClient(AmazonSQS client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
this.Client = client;
}
/// <summary>
/// Gets the Queue's attributes
/// </summary>
/// <param name="client"></param>
/// <param name="queueUrl"></param>
/// <returns></returns>
/// <remarks>
/// All - returns all values.
/// ApproximateNumberOfMessages — returns the approximate number of visible messages in a queue. For more information, see Resources Required to Process Messages in the Amazon SQS Developer Guide.
/// ApproximateNumberOfMessagesNotVisible — returns the approximate number of messages that are not timed-out and not deleted. For more information, see Resources Required to Process Messages in the Amazon SQS Developer Guide.
/// VisibilityTimeout — returns the visibility timeout for the queue. For more information about visibility timeout, see Visibility Timeout in the Amazon SQS Developer Guide.
/// CreatedTimestamp — returns the time when the queue was created (epoch time in seconds).
/// LastModifiedTimestamp — returns the time when the queue was last changed (epoch time in seconds).
/// Policy — returns the queue's policy.
/// MaximumMessageSize — returns the limit of how many bytes a message can contain before Amazon SQS rejects it.
/// MessageRetentionPeriod — returns the number of seconds Amazon SQS retains a message.
/// QueueArn — returns the queue's Amazon resource name (ARN).
/// </remarks>
public GetQueueAttributesResult GetQueueAttributes(AmazonSQS client, string queueUrl)
{
var request = new GetQueueAttributesRequest {
QueueUrl = queueUrl, AttributeName = new List <string>(new[] { "All" })
};
GetQueueAttributesResponse response = client.GetQueueAttributes(request);
return(response.GetQueueAttributesResult);
}
private static void EnsureSqs()
{
if (sqs == null)
{
lock (lockObject)
{
sqs = AWSClientFactory.CreateAmazonSQSClient();
}
}
}
/// <summary>
///
/// Gets one or all attributes of a queue. Queues currently have two attributes you can get: ApproximateNumberOfMessages and VisibilityTimeout.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">GetQueueAttributesRequest request</param>
public static void InvokeGetQueueAttributes(AmazonSQS service, GetQueueAttributesRequest request)
{
try
{
GetQueueAttributesResponse response = service.GetQueueAttributes(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" GetQueueAttributesResponse");
if (response.IsSetGetQueueAttributesResult())
{
Console.WriteLine(" GetQueueAttributesResult");
GetQueueAttributesResult getQueueAttributesResult = response.GetQueueAttributesResult;
List<Attribute> attributeList = getQueueAttributesResult.Attribute;
foreach (Attribute attribute in attributeList)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName())
{
Console.WriteLine(" Name");
Console.WriteLine(" {0}", attribute.Name);
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value");
Console.WriteLine(" {0}", attribute.Value);
}
}
}
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);
}
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Deleting SQS Queue at {0}", QueueUrl);
var request = new DeleteQueueRequest { QueueUrl = QueueUrl };
client.DeleteQueue(request);
Logger.LogMessage(MessageImportance.Normal, "Deleted SQS Queue at {0}", QueueUrl);
return true;
}
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;
}
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());
}
static void Main(string[] args)
{
Console.Title = "CloudServiceBus: Client";
AmazonSQS sqs = AwsFacade.GetSqsClient();
var requestQueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
//create a queue for responses:
var queueName = Guid.NewGuid().ToString();
var createQueueRequest = new CreateQueueRequest();
createQueueRequest.QueueName = queueName;
var createQueueResponse = sqs.CreateQueue(createQueueRequest);
var responseQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
var listener = new MessageListener();
ThreadPool.QueueUserWorkItem(new WaitCallback(listener.StartListening), responseQueueUrl);
Console.WriteLine("*");
Console.WriteLine("Sending messages on URL: {0}", requestQueueUrl);
Console.WriteLine("Receiving responses on URL: {0}", responseQueueUrl);
Console.WriteLine("*");
var messageBody = Console.ReadLine();
while (messageBody != "x")
{
var parts = messageBody.Split(' ');
if (parts[0] == "get")
{
var duration = int.Parse(parts[1]);
var serviceRequest = new GetChangedEmployeesRequest();
serviceRequest.LastChangeDate = DateTime.Now.AddDays(duration).Date;
serviceRequest.ResponseQueueUrl = responseQueueUrl;
var request = new SendMessageRequest();
request.QueueUrl = requestQueueUrl;
request.RequestToBody(serviceRequest);
SendMessage(request, sqs, serviceRequest);
}
if (parts[0] == "flush")
{
var serviceRequest = new FlushDataStoreRequest();
serviceRequest.StoreIdentifier = "Sixeyed-CloudServiceBus-ResponseData";
var request = new SendMessageRequest();
request.QueueUrl = requestQueueUrl;
request.RequestToBody(serviceRequest);
SendMessage(request, sqs, serviceRequest);
}
messageBody = Console.ReadLine();
}
}
public SQSQueueProcessor(IEnumerable <ServiceConfiguration> serviceConfigurations,
AmazonSQS amazonSQS,
IRequestThrottler requestThrottler,
ICreateSQSQueueCommand createSQSQueueCommand,
ErrorditeConfiguration configuration)
{
_serviceConfiguration = serviceConfigurations.First(c => c.IsActive);
_amazonSQS = amazonSQS;
_requestThrottler = requestThrottler;
_createSQSQueueCommand = createSQSQueueCommand;
_configuration = configuration;
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.High, "Waiting to receive a message from Queue {0}, Poll interval {1} seconds, Timeout in {2} seconds", QueueUrl, PollIntervalSeconds, TimeOutSeconds);
Message message = WaitForMessage(client);
MessageId = message.MessageId;
MessageBody = message.Body;
ReceiptHandle = message.ReceiptHandle;
Logger.LogMessage(MessageImportance.Normal, "Recieved message {0} from queue {1}", MessageId, 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);
}
/// <summary>
/// Receives a message from the SQS Queue
/// </summary>
/// <param name="client"></param>
/// <param name="queueUrl"></param>
/// <returns></returns>
private Message ReceiveMessage(AmazonSQS client)
{
var request = new ReceiveMessageRequest {
MaxNumberOfMessages = 1, QueueUrl = QueueUrl
};
ReceiveMessageResponse response = client.ReceiveMessage(request);
if (response.IsSetReceiveMessageResult())
{
return(response.ReceiveMessageResult.Message.FirstOrDefault());
}
return(null);
}
/// <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);
}
private string GetQueueArn(AmazonSQS client, string queueUrl)
{
var request = new GetQueueAttributesRequest {
QueueUrl = queueUrl, AttributeName = new List <string>(new[] { "QueueArn" })
};
GetQueueAttributesResponse response = client.GetQueueAttributes(request);
if (response.IsSetGetQueueAttributesResult())
{
return(response.GetQueueAttributesResult.Attribute.Where(x => x.Name == "QueueArn").First().Value);
}
throw new Exception("No SetQueueAttribute result");
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Deleting SQS Queue at {0}", QueueUrl);
var request = new DeleteQueueRequest {
QueueUrl = QueueUrl
};
client.DeleteQueue(request);
Logger.LogMessage(MessageImportance.Normal, "Deleted SQS Queue at {0}", QueueUrl);
return(true);
}
public AwsSqsHost(AmazonSQS sqsClient, IDictionary <string, string> queueUrls, int retryCount = DefaultRetryCount, TimeSpan?requestTimeOut = null)
: base(null, retryCount, requestTimeOut)
{
if (sqsClient == null)
{
throw new ArgumentNullException("sqsClient");
}
if (queueUrls == null)
{
throw new ArgumentNullException("queueUrls");
}
client = sqsClient;
QueueUrls = queueUrls;
}
/// <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);
}
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();
}
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();
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Creating SQS Queue {0}", QueueName);
var request = new CreateQueueRequest { QueueName = QueueName };
CreateQueueResponse response = client.CreateQueue(request);
if (response.IsSetCreateQueueResult())
{
QueueUrl = response.CreateQueueResult.QueueUrl;
Logger.LogMessage(MessageImportance.Normal, "Creates SQS Queue {0} at {1}", QueueName, QueueUrl);
return true;
}
Logger.LogMessage(MessageImportance.Normal, "Failed to create SQS Queue {0}", QueueName);
return false;
}
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 override bool Execute(AmazonSQS client)
{
var request = new SendMessageRequest { MessageBody = MessageBody, QueueUrl = QueueUrl };
SendMessageResponse response = client.SendMessage(request);
if (response.IsSetSendMessageResult())
{
MessageId = response.SendMessageResult.MessageId;
Logger.LogMessage(MessageImportance.Normal, "Sent message {0} to Queue {1}", MessageId, QueueUrl);
return true;
}
Logger.LogMessage(MessageImportance.High, "Message failed to send to to Queue {0}", QueueUrl);
return false;
}
static void Main(string[] args)
{
Console.Title = "CloudServiceBus: Service Provider";
Console.BackgroundColor = ConsoleColor.DarkGray;
Console.ForegroundColor = ConsoleColor.Black;
//register all the service handlers:
Container.RegisterAll<IServiceHandler>();
//create the queue service client:
SqsClient = AwsFacade.GetSqsClient();
//start listening:
StartHandlers();
Console.ReadLine();
}
protected override bool Execute(AmazonSQS client)
{
Log.LogMessage(MessageImportance.Normal, "Granting SendMessage rights to SQS Queue at {0}", QueueUrl);
string queueArn = GetQueueArn(client, QueueUrl);
Log.LogMessage(MessageImportance.Low, "Queue {0} Arn: {1}", QueueUrl, queueArn);
var request = new SetQueueAttributesRequest { QueueUrl = QueueUrl };
var attribute = new Attribute { Name = "Policy", Value = ConstructPolicy(queueArn, SourceArn) };
request.Attribute = new List<Attribute> { attribute };
client.SetQueueAttributes(request);
Logger.LogMessage(MessageImportance.Normal, "Granted rights for source {0} to SendMessage to SQS at {1}", SourceArn, QueueUrl);
return true;
}
/// <summary>
///
/// The ListQueues action returns a list of your queues.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">ListQueuesRequest request</param>
public static void InvokeListQueues(AmazonSQS service, ListQueuesRequest request)
{
try
{
ListQueuesResponse response = service.ListQueues(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" ListQueuesResponse");
if (response.IsSetListQueuesResult())
{
Console.WriteLine(" ListQueuesResult");
ListQueuesResult listQueuesResult = response.ListQueuesResult;
List<String> queueUrlList = listQueuesResult.QueueUrl;
foreach (String queueUrl in queueUrlList)
{
Console.WriteLine(" QueueUrl");
Console.WriteLine(" {0}", queueUrl);
}
}
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);
}
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Getting SQS Queue attributes for queue at {0}", QueueUrl);
GetQueueAttributesResult attributes = GetQueueAttributes(client, QueueUrl);
if (attributes.IsSetAttribute())
{
SetOutputProperties(attributes);
Logger.LogMessage(MessageImportance.Low, "Got SQS attributes for Queue {0}", QueueUrl);
return(true);
}
Logger.LogMessage(MessageImportance.High, "Failed to get SQS attributes for Queue {0}", QueueUrl);
return(false);
}
/// <summary>
/// Wait for a message on the Queue
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
/// <exception cref="TimeoutException">thrown if timeOutSeconds is exceeded.</exception>
private Message WaitForMessage(AmazonSQS client)
{
DateTime waitUntil = DateTime.Now.AddSeconds(TimeOutSeconds);
do
{
Message message = ReceiveMessage(client);
if (message != null)
{
return(message);
}
Thread.Sleep(new TimeSpan(0, 0, PollIntervalSeconds));
} while (DateTime.Now <= waitUntil);
throw new TimeoutException(string.Format("Timeout waiting for a message on the Queue {0}", QueueUrl));
}
protected override bool Execute(AmazonSQS client)
{
Logger.LogMessage(MessageImportance.Normal, "Receiving message from Queue {0}", QueueUrl);
var request = new ReceiveMessageRequest {
MaxNumberOfMessages = 1, QueueUrl = QueueUrl
};
ReceiveMessageResponse response = client.ReceiveMessage(request);
if (response.IsSetReceiveMessageResult())
{
Message message = response.ReceiveMessageResult.Message.FirstOrDefault();
ProcessMessage(message);
}
// return true even if no message received as the task executed ok.
return(true);
}
/// <summary>
///
/// The CreateQueue action creates a new queue. You must provide a queue name that is unique within the scope of the queues you own. The queue is assigned a queue URL; you must use this URL when performing actions on the queue. When you create a queue, if a queue with the same name already exists, CreateQueue returns the queue URL with an error indicating that the queue already exists.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">CreateQueueRequest request</param>
public static void InvokeCreateQueue(AmazonSQS service, CreateQueueRequest request)
{
try
{
CreateQueueResponse response = service.CreateQueue(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" CreateQueueResponse");
if (response.IsSetCreateQueueResult())
{
Console.WriteLine(" CreateQueueResult");
CreateQueueResult createQueueResult = response.CreateQueueResult;
if (createQueueResult.IsSetQueueUrl())
{
Console.WriteLine(" QueueUrl");
Console.WriteLine(" {0}", createQueueResult.QueueUrl);
}
}
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);
}
}
public void StartListening(object state)
{
_queueUrl = state as string;
if (!string.IsNullOrEmpty(_queueUrl))
{
_sqsClient = AwsFacade.GetSqsClient();
Console.WriteLine("*");
Console.WriteLine("Listening for messages on URL: {0}", _queueUrl);
Console.WriteLine("*");
while (true)
{
ReceiveMessage();
Thread.Sleep(ReceiveMessageWaitMilliseconds);
}
}
}
public void StartListening(object state)
{
_handler = state as IServiceHandler;
if (_handler != null)
{
_sqsClient = AwsFacade.GetSqsClient();
Console.WriteLine("*");
Console.WriteLine("Listening for messages on Queue: {0} with URL: {1}", _handler.QueueName, _handler.QueueUrl);
Console.WriteLine("*");
while (true)
{
ReceiveMessage();
Thread.Sleep(ReceiveMessageWaitMilliseconds);
}
}
}
public AmazonSQSMessageRetrievalInterface()
{
string awsAccessKeyId, awsSecretAccessKey;
try
{
System.Configuration.AppSettingsReader settings = new System.Configuration.AppSettingsReader();
awsAccessKeyId = (string)settings.GetValue("AwsAccessKeyId", typeof(string));
awsSecretAccessKey = (string)settings.GetValue("AwsSecretAccessKey", typeof(string));
queueUrl = (string)settings.GetValue("QueueUrl", typeof(string));
}
catch (InvalidOperationException)
{
throw new ApplicationException(
"Could not read AwsAccessKeyId or AwsSecretAccessKey from the configuration."
);
}
sqs = new AmazonSQSClient(awsAccessKeyId, awsSecretAccessKey);
}
/// <summary>
/// Default Constructor
/// </summary>
public MainPage()
{
InitializeComponent();
this.DataContext = this;
AWSCredentials credentials = new EnvironmentAWSCredentials();
sqs = new AmazonSQSClient(credentials);
this.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
if (string.Compare(e.PropertyName, "SelectedQueueIndex", System.StringComparison.OrdinalIgnoreCase) == 0)
{
if (_selectedQueueIndex > -1)
{
this.QueueName = this.QueueNames[_selectedQueueIndex];
this.HaveQueueUrl = true;
}
}
};
}
public CraneChatRequestSender()
{
// initialize Amazon SQSClient
AmazonSQSConfig sqsConfig = new AmazonSQSConfig();
sqsConfig.ServiceURL = ConfigurationManager.AppSettings["SQSServiceURL"].ToString();
m_sqsClient = AWSClientFactory.CreateAmazonSQSClient(sqsConfig);
// create 'Request' queue and save its URL
if (null != m_sqsClient)
{
try
{
CreateQueueRequest createQueueRequest = new CreateQueueRequest().WithQueueName("Request");
CreateQueueResponse createQueueResponse = m_sqsClient.CreateQueue(createQueueRequest);
m_requestQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
}
catch (AmazonSQSException /*sqsException*/)
{
throw;
}
}
}
protected override void SafeManagedResourcesDisposing()
{
m_sqsClient.Dispose();
m_sqsClient = null;
}
private static void EnsureSqs()
{
if (sqs == null)
{
lock (lockObject)
{
sqs = AWSClientFactory.CreateAmazonSQSClient();
}
}
}
internal DownloadFileCommand(ArchiveTransferManager manager, string vaultName, string archiveId, string filePath, DownloadOptions options)
{
this.manager = manager;
this.vaultName = vaultName;
this.archiveId = archiveId;
this.filePath = filePath;
this.options = options;
var credentials = ((AmazonGlacierClient)this.manager.GlacierClient).Credentials;
var regionName = Util.AWSSDKUtils.DetermineRegion(((AmazonGlacierClient)this.manager.GlacierClient).ServiceURL);
RegionEndpoint region = RegionEndpoint.GetBySystemName(regionName);
this.snsClient = new AmazonSimpleNotificationServiceClient(credentials, region);
this.sqsClient = new AmazonSQSClient(credentials, region);
if (this.options == null)
this.options = new DownloadOptions();
}
/// <summary>
///
/// Retrieves one or more messages from the specified queue, including the message body and message ID of each message. Messages returned by this action stay in the queue until you delete them. However, once a message is returned to a ReceiveMessage request, it is not returned on subsequent ReceiveMessage requests for the duration of the VisibilityTimeout. If you do not specify a VisibilityTimeout in the request, the overall visibility timeout for the queue is used for the returned messages.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">ReceiveMessageRequest request</param>
public static void InvokeReceiveMessage(AmazonSQS service, ReceiveMessageRequest request)
{
try
{
ReceiveMessageResponse response = service.ReceiveMessage(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" ReceiveMessageResponse");
if (response.IsSetReceiveMessageResult())
{
Console.WriteLine(" ReceiveMessageResult");
ReceiveMessageResult receiveMessageResult = response.ReceiveMessageResult;
List<Message> messageList = receiveMessageResult.Message;
foreach (Message message in messageList)
{
Console.WriteLine(" Message");
if (message.IsSetMessageId())
{
Console.WriteLine(" MessageId");
Console.WriteLine(" {0}", message.MessageId);
}
if (message.IsSetReceiptHandle())
{
Console.WriteLine(" ReceiptHandle");
Console.WriteLine(" {0}", message.ReceiptHandle);
}
if (message.IsSetMD5OfBody())
{
Console.WriteLine(" MD5OfBody");
Console.WriteLine(" {0}", message.MD5OfBody);
}
if (message.IsSetBody())
{
Console.WriteLine(" Body");
Console.WriteLine(" {0}", message.Body);
}
}
}
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);
}
}
public QueueAdmin(string awsAccessKey, string awsSecretKey)
{
this.client = AWSClientFactory.CreateAmazonSQSClient(
awsAccessKey, awsSecretKey
);
}
protected abstract bool Execute(AmazonSQS client);
private static void SendMessage(SendMessageRequest request, AmazonSQS sqs, ServiceRequest serviceRequest)
{
Console.WriteLine("Sending message, body: {0}, at: {1}", request.MessageBody, DateTime.Now.ToLongTimeString());
var response = sqs.SendMessage(request);
Console.WriteLine("Sent message, id: {0}, at: {1}", response.SendMessageResult.MessageId, DateTime.Now.ToLongTimeString());
}
/// <summary>
/// Construct a AWS SQS client if needed
/// </summary>
private void ConstructClientIfNeeded()
{
if (_client == null)
{
_client = _awsFactoryWrapper.CreateAmazonSqsClient(AwsAccessKey, AwsSecretAccessKey);
}
}
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();
}
