private static string GetQueueUrl(string queueName)
{
var request = new GetQueueUrlRequest(queueName);
var response = _client.GetQueueUrl(request);
if (response.HttpStatusCode != HttpStatusCode.OK) throw new Exception("Http error " + (int)response.HttpStatusCode);
return response.QueueUrl;
}
public void Init(Address address, TransactionSettings transactionSettings, Func<TransportMessage, bool> tryProcessMessage, Action<TransportMessage, Exception> endProcessMessage)
{
var getQueueUrlRequest = new GetQueueUrlRequest(address.ToSqsQueueName(ConnectionConfiguration));
GetQueueUrlResponse getQueueUrlResponse;
try
{
getQueueUrlResponse = SqsClient.GetQueueUrl(getQueueUrlRequest);
}
catch (Exception ex)
{
Logger.Error("Exception thrown from GetQueueUrl.", ex);
throw;
}
_queueUrl = getQueueUrlResponse.QueueUrl;
if (_purgeOnStartup)
{
// SQS only allows purging a queue once every 60 seconds or so.
// If you try to purge a queue twice in relatively quick succession,
// PurgeQueueInProgressException will be thrown.
// This will happen if you are trying to start an endpoint twice or more
// in that time.
try
{
SqsClient.PurgeQueue(_queueUrl);
}
catch (PurgeQueueInProgressException ex)
{
Logger.Warn("Multiple queue purges within 60 seconds are not permitted by SQS.", ex);
}
catch (Exception ex)
{
Logger.Error("Exception thrown from PurgeQueue.", ex);
throw;
}
}
_tryProcessMessage = tryProcessMessage;
_endProcessMessage = endProcessMessage;
if (transactionSettings != null)
_isTransactional = transactionSettings.IsTransactional;
else
_isTransactional = true;
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SQS.Model.GetQueueUrlRequest();
if (cmdletContext.QueueName != null)
{
request.QueueName = cmdletContext.QueueName;
}
if (cmdletContext.QueueOwnerAWSAccountId != null)
{
request.QueueOwnerAWSAccountId = cmdletContext.QueueOwnerAWSAccountId;
}
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);
}
/// <summary>
/// The method opens the queue
/// </summary>
public bool OpenQueue(string queuename, int maxnumberofmessages, RegionEndpoint regionendpoint,String AWSAccessKey="", String AWSSecretKey="")
{
ClearErrorInfo();
IsValid = false;
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;
}
private string GetQueueUrl(string queue)
{
System.Net.WebException exception = null;
int attempts = 0;
while (attempts < 3)
{
try
{
if (!queueUrls.ContainsKey(queue))
{
GetQueueUrlRequest request = new GetQueueUrlRequest();
request.QueueName = SanitiseQueueName(queue);
GetQueueUrlResponse response = client.GetQueueUrl(request);
queueUrls.Add(queue, response.GetQueueUrlResult.QueueUrl);
}
return queueUrls[queue];
}
catch (System.Net.WebException ex)
{
exception = ex;
}
attempts++;
System.Threading.Thread.Sleep(15); // give the remote server some time to recover
}
throw exception;
}
public static void SQSGetQueueUrl()
{
#region SQSGetQueueUrl
var client = new AmazonSQSClient();
var request = new GetQueueUrlRequest
{
QueueName = "MyTestQueue",
QueueOwnerAWSAccountId = "80398EXAMPLE"
};
var response = client.GetQueueUrl(request);
Console.WriteLine("Queue URL: " + response.QueueUrl);
#endregion
Console.ReadLine();
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueUrl operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.GetQueueUrl"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl 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<GetQueueUrlResponse> GetQueueUrlAsync(GetQueueUrlRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, GetQueueUrlRequest, GetQueueUrlResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Returns the URL of an existing queue. This action provides a simple way
/// to retrieve the URL of an Amazon SQS queue.
///
///
/// <para>
/// To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code>
/// parameter to specify the account ID of the queue's owner. The queue's owner must
/// grant you permission to access the queue. For more information about shared
/// queue access, see <a>AddPermission</a> or go to <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html">Shared
/// Queues</a> in the <i>Amazon SQS Developer Guide</i>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl service method.</param>
///
/// <returns>The response from the GetQueueUrl service method, as returned by SQS.</returns>
/// <exception cref="QueueDoesNotExistException">
/// The queue referred to does not exist.
/// </exception>
public GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest request)
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return Invoke<GetQueueUrlRequest,GetQueueUrlResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueUrl operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl 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<GetQueueUrlResponse> GetQueueUrlAsync(GetQueueUrlRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return InvokeAsync<GetQueueUrlRequest,GetQueueUrlResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
IAsyncResult invokeGetQueueUrl(GetQueueUrlRequest getQueueUrlRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new GetQueueUrlRequestMarshaller().Marshall(getQueueUrlRequest);
var unmarshaller = GetQueueUrlResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
public GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest request)
{
var q = queues.Where(kvp => kvp.Value.QueueDefinition.QueueName.Equals(request.QueueName, StringComparison.InvariantCultureIgnoreCase))
.Select(kvp => kvp.Value)
.SingleOrDefault();
if (q == null)
throw new QueueDoesNotExistException("Queue does not exist with namel [{0}]".Fmt(request.QueueName));
return new GetQueueUrlResponse
{
QueueUrl = q.QueueDefinition.QueueUrl
};
}
private Amazon.SQS.Model.GetQueueUrlResponse CallAWSServiceOperation(IAmazonSQS client, Amazon.SQS.Model.GetQueueUrlRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Queue Service (SQS)", "GetQueueUrl");
try
{
#if DESKTOP
return(client.GetQueueUrl(request));
#elif CORECLR
return(client.GetQueueUrlAsync(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;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueUrl operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl 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 GetQueueUrlAsync(GetQueueUrlRequest request, AmazonServiceCallback<GetQueueUrlRequest, GetQueueUrlResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<GetQueueUrlRequest,GetQueueUrlResponse> responseObject
= new AmazonServiceResult<GetQueueUrlRequest,GetQueueUrlResponse>((GetQueueUrlRequest)req, (GetQueueUrlResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<GetQueueUrlRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Returns the URL of an existing queue. This action provides a simple way to retrieve
/// the URL of an Amazon SQS queue.
///
///
/// <para>
/// To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code>
/// parameter to specify the account ID of the queue's owner. The queue's owner must grant
/// you permission to access the queue. For more information about shared queue access,
/// see <a>AddPermission</a> or go to <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html">Shared
/// Queues</a> in the <i>Amazon SQS Developer Guide</i>.
/// </para>
/// </summary>
/// <param name="queueName">The name of the queue whose URL must be fetched. Maximum 80 characters; alphanumeric characters, hyphens (-), and underscores (_) are allowed.</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>
///
/// <returns>The response from the GetQueueUrl service method, as returned by SQS.</returns>
/// <exception cref="Amazon.SQS.Model.QueueDoesNotExistException">
/// The queue referred to does not exist.
/// </exception>
public void GetQueueUrlAsync(string queueName, AmazonServiceCallback<GetQueueUrlRequest, GetQueueUrlResponse> callback, AsyncOptions options = null)
{
var request = new GetQueueUrlRequest();
request.QueueName = queueName;
GetQueueUrlAsync(request, callback, options);
}
public static bool GetQueueUrlRquestMatches(GetQueueUrlRequest request, string expectedQueueName)
{
return request.QueueName.Equals(expectedQueueName);
}
/// <summary>
/// <para>The <c>GetQueueUrl</c> action returns the URL of an existing queue.</para>
/// </summary>
///
/// <param name="getQueueUrlRequest">Container for the necessary parameters to execute the GetQueueUrl service method on AmazonSQS.</param>
///
/// <returns>The response from the GetQueueUrl service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="QueueDoesNotExistException"/>
public GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest getQueueUrlRequest)
{
IAsyncResult asyncResult = invokeGetQueueUrl(getQueueUrlRequest, null, null, true);
return EndGetQueueUrl(asyncResult);
}
public Task<GetQueueUrlResponse> GetQueueUrlAsync(GetQueueUrlRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new NotImplementedException();
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueUrl operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.GetQueueUrl"/>
/// </summary>
///
/// <param name="getQueueUrlRequest">Container for the necessary parameters to execute the GetQueueUrl 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 EndGetQueueUrl
/// operation.</returns>
public IAsyncResult BeginGetQueueUrl(GetQueueUrlRequest getQueueUrlRequest, AsyncCallback callback, object state)
{
return invokeGetQueueUrl(getQueueUrlRequest, callback, state, false);
}
public IQueue GetQueueById(string queueId)
{
GetQueueUrlRequest request = new GetQueueUrlRequest()
.WithQueueName(queueId);
var response = _sqsClient.GetQueueUrl(request);
return new AwsQueue(response.GetQueueUrlResult.QueueUrl);
}
/// <summary>
/// Returns the URL of an existing queue. This action provides a simple way to retrieve
/// the URL of an Amazon SQS queue.
///
///
/// <para>
/// To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code>
/// parameter to specify the account ID of the queue's owner. The queue's owner must grant
/// you permission to access the queue. For more information about shared queue access,
/// see <code> <a>AddPermission</a> </code> or see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html">Shared
/// Queues</a> in the <i>Amazon SQS Developer Guide</i>.
/// </para>
/// </summary>
/// <param name="queueName">The name of the queue whose URL must be fetched. Maximum 80 characters. Valid values: alphanumeric characters, hyphens (<code>-</code>), and underscores (<code>_</code>). 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 GetQueueUrl service method, as returned by SQS.</returns>
/// <exception cref="Amazon.SQS.Model.QueueDoesNotExistException">
/// The queue referred to doesn't exist.
/// </exception>
public Task<GetQueueUrlResponse> GetQueueUrlAsync(string queueName, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new GetQueueUrlRequest();
request.QueueName = queueName;
return GetQueueUrlAsync(request, cancellationToken);
}
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();
}
/// <summary>
/// Returns the URL of an existing queue. This action provides a simple way
/// to retrieve the URL of an Amazon SQS queue.
///
///
/// <para>
/// To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code>
/// parameter to specify the account ID of the queue's owner. The queue's owner must
/// grant you permission to access the queue. For more information about shared
/// queue access, see <a>AddPermission</a> or go to <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html">Shared
/// Queues</a> in the <i>Amazon SQS Developer Guide</i>.
/// </para>
/// </summary>
/// <param name="queueName">The name of the queue whose URL must be fetched. Maximum 80 characters; alphanumeric characters, hyphens (-), and underscores (_) are allowed.</param>
///
/// <returns>The response from the GetQueueUrl service method, as returned by SQS.</returns>
/// <exception cref="QueueDoesNotExistException">
/// The queue referred to does not exist.
/// </exception>
public GetQueueUrlResponse GetQueueUrl(string queueName)
{
var request = new GetQueueUrlRequest();
request.QueueName = queueName;
return GetQueueUrl(request);
}
internal GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest request)
{
var task = GetQueueUrlAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueUrl operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl 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 EndGetQueueUrl
/// operation.</returns>
public IAsyncResult BeginGetQueueUrl(GetQueueUrlRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return BeginInvoke<GetQueueUrlRequest>(request, marshaller, unmarshaller,
callback, state);
}
IAsyncResult invokeGetQueueUrl(GetQueueUrlRequest request, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
}
/// <summary>
/// <para> Returns the URL of an existing queue. This action provides a simple way to retrieve the URL of an Amazon SQS queue. </para> <para> To
/// access a queue that belongs to another AWS account, use the <c>QueueOwnerAWSAccountId</c> parameter to specify the account ID of the queue's
/// owner. The queue's owner must grant you permission to access the queue. For more information about shared queue access, see AddPermission or
/// go to <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html">Shared Queues</a> in the
/// <i>Amazon SQS Developer Guide</i> .
/// </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueUrl service method on AmazonSQS.</param>
///
/// <returns>The response from the GetQueueUrl service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.QueueDoesNotExistException" />
public GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest request)
{
var task = GetQueueUrlAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <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;
}
/// <summary>
/// <para>The <c>GetQueueUrl</c> action returns the URL of an existing queue.</para>
/// </summary>
///
/// <param name="getQueueUrlRequest">Container for the necessary parameters to execute the GetQueueUrl service method on AmazonSQS.</param>
///
/// <returns>The response from the GetQueueUrl service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.QueueDoesNotExistException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<GetQueueUrlResponse> GetQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.GetInstance();
return Invoke<IRequest, GetQueueUrlRequest, GetQueueUrlResponse>(getQueueUrlRequest, marshaller, unmarshaller, signer, cancellationToken);
}
public override bool QueueExists(string queue)
{
try
{
GetQueueUrlRequest request = new GetQueueUrlRequest();
request.QueueName = SanitiseQueueName(queue);
GetQueueUrlResponse response = client.GetQueueUrl(request);
return true;
}
catch (AmazonSQSException)
{
return false;
}
}