private AmazonSQSClient InitializeQueue()
{
var client = new AmazonSQSClient(Utility.GetRegionEndpoint());
ListQueuesRequest listQueuesRequest = new ListQueuesRequest
{
QueueNamePrefix = QueueName
};
var listQueuesResponse = client.ListQueues(listQueuesRequest);
bool found = listQueuesResponse.ListQueuesResult.QueueUrls.Any(s => s == QueueName);
if (found == false)
{
var createQueueResponse = client.CreateQueue(new CreateQueueRequest
{
QueueName = QueueName
});
QueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
}
else
{
QueueUrl = client.GetQueueUrl(
new GetQueueUrlRequest
{
QueueName = _queueName
}
).GetQueueUrlResult.QueueUrl;
}
return 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 override void EndProcessing()
{
AmazonSQS client = GetClient();
ListQueuesRequest request = new ListQueuesRequest();
request.QueueNamePrefix = this.QueueNamePrefix;
ListQueuesResponse response = client.ListQueues(request);
WriteObject(response.ListQueuesResult.QueueUrl, true);
}
/// <summary>
/// Gets a list of all registered message queues
/// </summary>
/// <param name="listQueuesRequest">The list queue request object.</param>
/// <returns>A list of all registered message queues.</returns>
public virtual ListQueuesResponse GetAllQueueNames(ListQueuesRequest listQueuesRequest)
{
if (listQueuesRequest == null)
{
throw new ArgumentNullException("listQueuesRequest");
}
// Log.Debug("SqsClient: Getting all queue names");
var listQueuesResponse = this.Client.ListQueues(listQueuesRequest);
if (!listQueuesResponse.IsSetListQueuesResult())
{
throw new InvalidOperationException("Could not retrieve list of message queues from Amazon SQS.");
}
return listQueuesResponse;
}
private void button1_Click(object sender, EventArgs e)
{
CreateQueueRequest sqsRequest = new CreateQueueRequest();
sqsRequest.QueueName = "MYFirstQueue";
CreateQueueResponse createQueueResponse = sqs.CreateQueue(sqsRequest);
myQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
//Confirming the queue exists
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
ListQueuesResponse listQueuesResponse = sqs.ListQueues(listQueuesRequest);
SendMessageRequest sendMessageRequest = new SendMessageRequest();
sendMessageRequest.QueueUrl = myQueueUrl;
sendMessageRequest.MessageBody = txtPushMsg.Text;
sqs.SendMessage(sendMessageRequest);
}
public ObservableCollection<QueueDescription> ListQueues()
{
var lqr = new ListQueuesRequest();
var response = this.client.ListQueues(lqr);
var result = new ObservableCollection<QueueDescription>();
foreach (string url in response.QueueUrls) {
string name = url.Substring(url.LastIndexOf('/') + 1);
result.Add(new QueueDescription() {
Name = name,
Url = url
});
}
return result;
}
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();
}
/// <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);
}
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SQS.Model.ListQueuesRequest();
if (cmdletContext.MaxResult != null)
{
request.MaxResults = cmdletContext.MaxResult.Value;
}
if (cmdletContext.NextToken != null)
{
request.NextToken = cmdletContext.NextToken;
}
if (cmdletContext.QueueNamePrefix != null)
{
request.QueueNamePrefix = cmdletContext.QueueNamePrefix;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
public virtual bool DoesQueueExist(string queueName)
{
var exists = false;
var client = this.GetClient();
var request = new ListQueuesRequest
{
QueueNamePrefix = queueName
};
var response = client.ListQueues(request);
response.ListQueuesResult.QueueUrl.ForEach(x =>
{
if (x.EndsWith(queueName))
{
exists = true;
}
});
return exists;
}
/// <summary>
/// Initiates the asynchronous execution of the ListQueues operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListQueues operation on AmazonSQSClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListQueues
/// operation.</returns>
public IAsyncResult BeginListQueues(ListQueuesRequest request, AsyncCallback callback, object state)
{
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.Instance;
return BeginInvoke<ListQueuesRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Returns a list of your queues. The maximum number of queues that can be returned
/// is 1000. If you specify a value for the optional <code>QueueNamePrefix</code>
/// parameter, only queues with a name beginning with the specified value are returned.
/// </summary>
/// <param name="queueNamePrefix">A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned.</param>
///
/// <returns>The response from the ListQueues service method, as returned by SQS.</returns>
public ListQueuesResponse ListQueues(string queueNamePrefix)
{
var request = new ListQueuesRequest();
request.QueueNamePrefix = queueNamePrefix;
return ListQueues(request);
}
/// <summary>
/// Returns a list of your queues. The maximum number of queues that can be returned
/// is 1000. If you specify a value for the optional <code>QueueNamePrefix</code>
/// parameter, only queues with a name beginning with the specified value are returned.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListQueues service method.</param>
///
/// <returns>The response from the ListQueues service method, as returned by SQS.</returns>
public ListQueuesResponse ListQueues(ListQueuesRequest request)
{
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.Instance;
return Invoke<ListQueuesRequest,ListQueuesResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Returns a list of your queues. The maximum number of queues that can be returned is
/// 1,000. If you specify a value for the optional <code>QueueNamePrefix</code> parameter,
/// only queues with a name that begins with the specified value are returned.
/// </summary>
/// <param name="queueNamePrefix">A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned. Queue names are case-sensitive.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the ListQueues service method, as returned by SQS.</returns>
public Task<ListQueuesResponse> ListQueuesAsync(string queueNamePrefix, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new ListQueuesRequest();
request.QueueNamePrefix = queueNamePrefix;
return ListQueuesAsync(request, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the ListQueues operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListQueues operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<ListQueuesResponse> ListQueuesAsync(ListQueuesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.Instance;
return InvokeAsync<ListQueuesRequest,ListQueuesResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the ListQueues operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListQueues operation on AmazonSQSClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void ListQueuesAsync(ListQueuesRequest request, AmazonServiceCallback<ListQueuesRequest, ListQueuesResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<ListQueuesRequest,ListQueuesResponse> responseObject
= new AmazonServiceResult<ListQueuesRequest,ListQueuesResponse>((ListQueuesRequest)req, (ListQueuesResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<ListQueuesRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
IAsyncResult invokeListQueues(ListQueuesRequest listQueuesRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new ListQueuesRequestMarshaller().Marshall(listQueuesRequest);
var unmarshaller = ListQueuesResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// Paginator for ListQueues operation
///</summary>
public IListQueuesPaginator ListQueues(ListQueuesRequest request)
{
return(new ListQueuesPaginator(this.client, request));
}
internal ListQueuesResponse ListQueues(ListQueuesRequest request)
{
var task = ListQueuesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
public static void Main(string[] args)
{
NameValueCollection appConfig = ConfigurationManager.AppSettings;
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient(
appConfig["AWSAccessKey"],
appConfig["AWSSecretKey"]
);
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 = sqs.CreateQueue(sqsRequest);
String myQueueUrl;
myQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
//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();
//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;
}
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();
}
private Amazon.SQS.Model.ListQueuesResponse CallAWSServiceOperation(IAmazonSQS client, Amazon.SQS.Model.ListQueuesRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Queue Service (SQS)", "ListQueues");
try
{
#if DESKTOP
return(client.ListQueues(request));
#elif CORECLR
return(client.ListQueuesAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
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 Main(string[] args)
{
var sqs = new AmazonSQSClient();
try
{
Console.WriteLine("===========================================");
Console.WriteLine("Getting Started with Amazon SQS");
Console.WriteLine("===========================================\n");
//Confirming the queue exists
var listQueuesRequest = new ListQueuesRequest();
var listQueuesResponse = sqs.ListQueues(listQueuesRequest);
string myQueueUrl = string.Empty;
Console.WriteLine("Printing list of Amazon SQS queues.\n");
bool queueExists = false;
if (listQueuesResponse.QueueUrls != null)
{
foreach (String queueUrl in listQueuesResponse.QueueUrls)
{
Console.WriteLine(" QueueUrl: {0}", queueUrl);
if (queueUrl.EndsWith("MyQueue"))
{
queueExists = true;
myQueueUrl = queueUrl;
break;
}
}
}
Console.WriteLine();
if (!queueExists)
{
//Creating a queue
Console.WriteLine("Create a queue called MyQueue.\n");
var sqsRequest = new CreateQueueRequest { QueueName = "MyQueue" };
var createQueueResponse = sqs.CreateQueue(sqsRequest);
myQueueUrl = createQueueResponse.QueueUrl;
}
//Sending a message
Console.WriteLine("Sending a message to MyQueue.\n");
var sendMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueUrl, //URL from initial queue creation
MessageBody = string.Format("ATL MEETUP - This is my message text from server - {0}",System.Environment.MachineName)
};
sqs.SendMessage(sendMessageRequest);
////Receiving a message
//var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = myQueueUrl };
//var receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
//if (receiveMessageResponse.Messages != null)
//{
// Console.WriteLine("Printing received message.\n");
// foreach (var message in receiveMessageResponse.Messages)
// {
// Console.WriteLine(" Message");
// if (!string.IsNullOrEmpty(message.MessageId))
// {
// Console.WriteLine(" MessageId: {0}", message.MessageId);
// }
// if (!string.IsNullOrEmpty(message.ReceiptHandle))
// {
// Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
// }
// if (!string.IsNullOrEmpty(message.MD5OfBody))
// {
// Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
// }
// if (!string.IsNullOrEmpty(message.Body))
// {
// Console.WriteLine(" Body: {0}", message.Body);
// }
// foreach (string attributeKey in message.Attributes.Keys)
// {
// Console.WriteLine(" Attribute");
// Console.WriteLine(" Name: {0}", attributeKey);
// var value = message.Attributes[attributeKey];
// Console.WriteLine(" Value: {0}", string.IsNullOrEmpty(value) ? "(no value)" : value);
// }
// }
// var messageRecieptHandle = receiveMessageResponse.Messages[0].ReceiptHandle;
// //Deleting a message
// Console.WriteLine("Deleting the message.\n");
// var deleteRequest = new DeleteMessageRequest { QueueUrl = myQueueUrl, 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("Press Enter to continue...");
Console.Read();
}
private void btnListQueue_Click(object sender, RoutedEventArgs e)
{
ListQueuesRequest listQueue = new ListQueuesRequest();
this.Dispatcher.BeginInvoke(() =>
{
this.QueueNames.Clear();
this.QueueNames.Add("Please wait...");
});
sqs.OnSQSResponse += GetListQueueResponse;
sqs.ListQueues(listQueue);
}
/// <summary>
/// Initiates the asynchronous execution of the ListQueues operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.ListQueues"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListQueues operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<ListQueuesResponse> ListQueuesAsync(ListQueuesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, ListQueuesRequest, ListQueuesResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
public Task<ListQueuesResponse> ListQueuesAsync(ListQueuesRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new NotImplementedException();
}
public static void Main(string[] args)
{
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USWest2);
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 = sqs.CreateQueue(sqsRequest);
String myQueueUrl;
myQueueUrl = createQueueResponse.QueueUrl;
//Confirming the queue exists
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
ListQueuesResponse listQueuesResponse = sqs.ListQueues(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 = "This is my message text.";
sqs.SendMessage(sendMessageRequest);
//Receiving a message
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = myQueueUrl;
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
Console.WriteLine("Printing received message.\n");
foreach (Message message in receiveMessageResponse.Messages)
{
Console.WriteLine(" Message");
Console.WriteLine(" MessageId: {0}", message.MessageId);
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
Console.WriteLine(" Body: {0}", message.Body);
foreach (KeyValuePair<string, string> entry in message.Attributes)
{
Console.WriteLine(" Attribute");
Console.WriteLine(" Name: {0}", entry.Key);
Console.WriteLine(" Value: {0}", entry.Value);
}
}
String messageRecieptHandle = receiveMessageResponse.Messages[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("Press Enter to continue...");
Console.Read();
}
/// <summary>Check to see if our queue already exists in SQS</summary>
/// <returns>True if the queue already exists</returns>
private bool DoesQueueExist()
{
Project.Log(Level.Info, "Checking to see if queue exists...");
using (Client) {
try {
var request = new ListQueuesRequest();
var response = Client.ListQueues(request);
if (response.IsSetListQueuesResult()) {
var result = response.ListQueuesResult;
foreach (var queueUrl in result.QueueUrl) {
if (queueUrl.Contains(QueueName)) {
Project.Log(Level.Info, "Queue '{0}' exists with URL: {1}", QueueName, queueUrl);
return true;
}
}
}
} catch (AmazonS3Exception ex) {
ShowError(ex);
}
}
Project.Log(Level.Info, "Queue '{0}' doesn't exist!", QueueName);
return false;
}
internal ListQueuesPaginator(IAmazonSQS client, ListQueuesRequest request)
{
this._client = client;
this._request = request;
}
/// <summary>
/// <para>Returns a list of your queues.</para>
/// </summary>
///
/// <param name="listQueuesRequest">Container for the necessary parameters to execute the ListQueues service method on AmazonSQS.</param>
///
/// <returns>The response from the ListQueues service method, as returned by AmazonSQS.</returns>
///
public ListQueuesResponse ListQueues(ListQueuesRequest listQueuesRequest)
{
IAsyncResult asyncResult = invokeListQueues(listQueuesRequest, null, null, true);
return EndListQueues(asyncResult);
}
/// <summary>
/// <para>Returns a list of your queues. The maximum number of queues that can be returned is 1000. If you specify a value for the optional
/// <c>QueueNamePrefix</c> parameter, only queues with a name beginning with the specified value are returned.</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListQueues service method on AmazonSQS.</param>
///
/// <returns>The response from the ListQueues service method, as returned by AmazonSQS.</returns>
public ListQueuesResponse ListQueues(ListQueuesRequest request)
{
var task = ListQueuesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the ListQueues operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.ListQueues"/>
/// </summary>
///
/// <param name="listQueuesRequest">Container for the necessary parameters to execute the ListQueues operation on AmazonSQS.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListQueues
/// operation.</returns>
public IAsyncResult BeginListQueues(ListQueuesRequest listQueuesRequest, AsyncCallback callback, object state)
{
return invokeListQueues(listQueuesRequest, callback, state, false);
}
/// <summary>
/// <para>Returns a list of your queues.</para>
/// </summary>
///
/// <param name="listQueuesRequest">Container for the necessary parameters to execute the ListQueues service method on AmazonSQS.</param>
///
/// <returns>The response from the ListQueues service method, as returned by AmazonSQS.</returns>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<ListQueuesResponse> ListQueuesAsync(ListQueuesRequest listQueuesRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListQueuesRequestMarshaller();
var unmarshaller = ListQueuesResponseUnmarshaller.GetInstance();
return Invoke<IRequest, ListQueuesRequest, ListQueuesResponse>(listQueuesRequest, marshaller, unmarshaller, signer, cancellationToken);
}
public ListQueuesResponse ListQueues(ListQueuesRequest request)
{
var urls = string.IsNullOrEmpty(request.QueueNamePrefix)
? queues.Keys
: queues.Values
.Where(q => q.QueueDefinition
.QueueName.StartsWith(request.QueueNamePrefix, StringComparison.InvariantCultureIgnoreCase))
.Select(q => q.QueueDefinition.QueueUrl);
var response = new ListQueuesResponse
{
QueueUrls = urls.ToList()
};
return response;
}