internal GetQueueUrlResponse GetQueueUrl(GetQueueUrlRequest request)
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return(Invoke <GetQueueUrlRequest, GetQueueUrlResponse>(request, marshaller, unmarshaller));
}
static void Main(string[] args)
{
Console.WriteLine("Initializing Amazon SQS Client and getting queue URL...");
var sqsClient = new AmazonSQSClient();
var getQueueUrlRequest = new GetQueueUrlRequest
{
QueueName = "DemoMasterWorkerPattern",
QueueOwnerAWSAccountId = "545983628851"
};
var getQueueUrlResponse = sqsClient.GetQueueUrlAsync(getQueueUrlRequest).Result;
var queueUrl = getQueueUrlResponse.QueueUrl;
Console.WriteLine($"Received Queue URL: {queueUrl}");
while (true)
{
Console.Write("Type a message to be sent to the queue or type 'exit' to quit: ");
var message = Console.ReadLine();
if (string.Equals(message, "exit", StringComparison.OrdinalIgnoreCase))
{
break;
}
Console.WriteLine($"Sending message with content '{message}' to the queue...");
var sendMessageRequest = new SendMessageRequest();
sendMessageRequest.QueueUrl = queueUrl;
sendMessageRequest.MessageBody = message;
var sendMessageResponse = sqsClient.SendMessageAsync(sendMessageRequest).Result;
Console.WriteLine("Message has been sent.");
Console.WriteLine($"HttpStatusCode: {sendMessageResponse.HttpStatusCode}");
}
}
/// <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.</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, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueUrlRequestMarshaller();
var unmarshaller = GetQueueUrlResponseUnmarshaller.Instance;
return(Invoke <IRequest, GetQueueUrlRequest, GetQueueUrlResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
public async Task <IActionResult> SQS()
{
var results = new List <string>();
var attrs = new Dictionary <string, string>();
attrs.Add(QueueAttributeName.VisibilityTimeout, "10");
var createQueueRequest = new CreateQueueRequest
{
QueueName = "borislav_queue-1",
Attributes = attrs
};
CreateQueueResponse createQueueResponse = await _sqsClient.CreateQueueAsync(createQueueRequest);
results.Add($"Queue '{createQueueRequest.QueueName}' created with status {createQueueResponse.HttpStatusCode}");
var request = new GetQueueUrlRequest
{
QueueName = "borislav_queue-1",
QueueOwnerAWSAccountId = "363590124413"
};
GetQueueUrlResponse urlResponse = await _sqsClient.GetQueueUrlAsync(request);
string url = urlResponse.QueueUrl;
var sendMessageRequest1 = new SendMessageRequest()
{
QueueUrl = url,
MessageBody = "{SQS_QUEUE_MESSAGE_1}"
};
var sendMessageResponse1 = await _sqsClient.SendMessageAsync(sendMessageRequest1);
results.Add($"Message {sendMessageRequest1.MessageBody} sent with status {sendMessageResponse1.HttpStatusCode}");
var sendMessageRequest2 = new SendMessageRequest()
{
QueueUrl = url,
MessageBody = "{SQS_QUEUE_MESSAGE_2}"
};
var sendMessageResponse2 = await _sqsClient.SendMessageAsync(sendMessageRequest2);
results.Add($"Message {sendMessageRequest2.MessageBody} sent with status {sendMessageResponse2.HttpStatusCode}");
var receiveMessageRequest = new ReceiveMessageRequest {
QueueUrl = url
};
var receiveMessageResponse1 = await _sqsClient.ReceiveMessageAsync(receiveMessageRequest);
var receiveMessageResponse2 = await _sqsClient.ReceiveMessageAsync(receiveMessageRequest);
var receiveMessageResponse3 = await _sqsClient.ReceiveMessageAsync(receiveMessageRequest);
results.AddRange(await ProcessMessages(receiveMessageResponse1, url));
results.AddRange(await ProcessMessages(receiveMessageResponse2, url));
//results.AddRange(await ProcessMessages(receiveMessageResponse3, url));
ViewBag.Results = new List <string>();
ViewBag.Results.AddRange(results);
return(View());
}
private void GetMessages()
{
var queueUrlRequest = new GetQueueUrlRequest("Messenger.fifo");
var queueUrl = _sqsClient.GetQueueUrl(queueUrlRequest).QueueUrl;
var receiveMessageRequest = new ReceiveMessageRequest {
QueueUrl = queueUrl
};
while ()
{
Task.Delay(TimeSpan.FromSeconds(1)).Wait();
var receiveMessageResponse = _sqsClient.ReceiveMessage(receiveMessageRequest);
foreach (var message in receiveMessageResponse.Messages)
{
var deserializedMessage = JsonConvert.DeserializeObject <MessageModel>(message.Body);
if (deserializedMessage.ChatId.Equals(_parentViewModel.ChatId, StringComparison.InvariantCulture) && !deserializedMessage.Author.Equals(_parentViewModel.Author))
{
NewMessageReceived?.Invoke(deserializedMessage);
var messageRecieptHandle = receiveMessageResponse.Messages[0].ReceiptHandle;
var deleteRequest = new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = messageRecieptHandle
};
_sqsClient.DeleteMessage(deleteRequest);
}
}
}
}
async Task ConfigureLambdaWithQueueAsync(string queueName)
{
string queueArn = null;
AmazonSQSClient sqsClient = AwsFactory.CreateClient <AmazonSQSClient>();
GetQueueUrlRequest queueUrlReq = new GetQueueUrlRequest();
queueUrlReq.QueueName = queueName;
GetQueueUrlResponse getQueueUrlResp = await sqsClient.GetQueueUrlAsync(queueUrlReq);
GetQueueAttributesRequest queueAttribReq = new GetQueueAttributesRequest();
queueAttribReq.AttributeNames.Add(QueueAttributeName.QueueArn);
queueAttribReq.QueueUrl = getQueueUrlResp.QueueUrl;
var queueAttribResp = await sqsClient.GetQueueAttributesAsync(queueAttribReq);
queueArn = queueAttribResp.QueueARN;
AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>();
CreateEventSourceMappingRequest eventMappingReq = new CreateEventSourceMappingRequest();
eventMappingReq.FunctionName = "WebhookDispatcher";
eventMappingReq.BatchSize = 10;
eventMappingReq.Enabled = true;
eventMappingReq.EventSourceArn = queueArn;
await lambdaClient.CreateEventSourceMappingAsync(eventMappingReq);
}
public void TestGetQueueUrl()
{
string queueName = "TestGetQueueUrl" + DateTime.Now.Ticks;
CreateQueueResponse createResponse = Client.CreateQueue(new CreateQueueRequest()
{
QueueName = queueName
});
try
{
GetQueueUrlRequest request = new GetQueueUrlRequest()
{
QueueName = queueName
};
GetQueueUrlResponse response = Client.GetQueueUrl(request);
Assert.AreEqual(createResponse.QueueUrl, response.QueueUrl);
}
finally
{
Client.DeleteQueue(new DeleteQueueRequest()
{
QueueUrl = createResponse.QueueUrl
});
}
}
public async Task TestCreateQueueAsync()
{
queueName = setQueueName();
// Check if any queue is already created
var sqsQueueList = await sqsClient.ListQueuesAsync(prefix);
Assert.IsFalse(sqsQueueList.QueueUrls.Count >= 1, "There is something in the queue already");
// Create the queue
CreateQueueResponse createResponse = await sqsClient.CreateQueueAsync(queueName);
// Get the queue list. Assert is added to make sure that the queue is created and make sure that we only create 1 queue
sqsQueueList = await sqsClient.ListQueuesAsync(prefix);
Assert.IsTrue(sqsQueueList.QueueUrls.Count == 1, "Queue is not created or more than one queue is created");
// Verify the queue list contains the queue name created before
Assert.IsTrue(sqsQueueList.QueueUrls[0].Contains(queueName), "Queue name is not the same");
// Verify the response created from when creating the queue is the same as the one we get from get queue URL
var request = new GetQueueUrlRequest(queueName);
var response = sqsClient.GetQueueUrlAsync(request);
Assert.AreEqual(createResponse.QueueUrl, response.Result.QueueUrl, "The queue URL is not the same");
}
private string getQueueUrl(string queueName)
{
GetQueueUrlResponse s = null;
string result = string.Empty;
try
{
GetQueueUrlRequest urlQueueRequest = new GetQueueUrlRequest
{
QueueName = queueName
};
try
{
s = amazonSQSClient.GetQueueUrlAsync(urlQueueRequest).Result;
}
catch (System.AggregateException)
{
return(createQueue(queueName));
}
if (s.QueueUrl.Any())
{
return(s.QueueUrl);
}
else
{
return(createQueue(queueName));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task GetQueueURLTest()
{
var mockClient = new Mock <IAmazonSQS>();
mockClient.Setup(client => client.GetQueueUrlAsync(
It.IsAny <GetQueueUrlRequest>(),
It.IsAny <CancellationToken>()))
.Returns((GetQueueUrlRequest r,
CancellationToken token) =>
{
return(Task.FromResult(new GetQueueUrlResponse()
{
QueueUrl = _queueUrl,
HttpStatusCode = HttpStatusCode.OK,
}));
});
var client = mockClient.Object;
var request = new GetQueueUrlRequest
{
QueueName = "Example_Queue"
};
var getQueueUrlRequest = new GetQueueUrlRequest();
var response = await client.GetQueueUrlAsync(request);
bool ok = response.HttpStatusCode == HttpStatusCode.OK;
Assert.True(ok, $"Retrieved the URL for the queue: {response.QueueUrl}.");
}
static async Task PushToSQS(IClient client, string accountId)
{
var source = new CancellationTokenSource();
var sqsClient = new AmazonSQSClient(RegionEndpoint.USEast1);
var urlRequest = new GetQueueUrlRequest
{
QueueName = AWSConstructs.Names.FroniusIngressQueue,
QueueOwnerAWSAccountId = accountId
};
var url = (await sqsClient.GetQueueUrlAsync(urlRequest))?.QueueUrl;
if (url == null)
{
throw new Exception($"Failed to get SQS URL for: {JsonSerializer.Serialize(urlRequest)}");
}
Response?dataLast = null;
while (true)
{
var data = await client.GetPowerFlowRealtimeData(source.Token);
if (data?.Head.Timestamp == dataLast?.Head.Timestamp)
{
await Task.Delay(10);
continue;
}
var dataJson = JsonSerializer.Serialize(data);
var message = new SendMessageRequest(url, dataJson);
var response = await sqsClient.SendMessageAsync(message);
Console.WriteLine($"{response.HttpStatusCode} | {response.MessageId} | {dataJson}");
dataLast = data;
}
}
private async Task <string> GetQueueURL()
{
var request = new GetQueueUrlRequest(QueueName);
var result = await _client.GetQueueUrlAsync(request);
return(result.QueueUrl);
}
/// <summary>
/// Gets the URL for the queue from its name.
/// </summary>
/// <param name="queueName">The name of the queue</param>
/// <returns></returns>
private async Task <string> GetQueueUrlAsync(string queueName)
{
var request = new GetQueueUrlRequest(queueName);
var response = await _client.GetQueueUrlAsync(request);
return(response.QueueUrl);
}
async Task VerifyQueueDeleted(string queueName, string prefix = null)
{
if (prefix == null)
{
prefix = DefaultConfigurationValues.QueueNamePrefix;
}
var getQueueUrlRequest = new GetQueueUrlRequest($"{prefix}{queueName}");
GetQueueUrlResponse queueUrlResponse;
var backOff = 0;
var executions = 0;
do
{
try
{
backOff = executions * executions * verificationBackoffInterval;
await Task.Delay(backOff);
executions++;
queueUrlResponse = await sqs.GetQueueUrlAsync(getQueueUrlRequest).ConfigureAwait(false);
}
catch (QueueDoesNotExistException)
{
// expected
queueUrlResponse = null;
}
} while (queueUrlResponse != null && backOff < maximumBackoffInterval);
Assert.IsNull(queueUrlResponse);
}
public static async Task <string> GetUrl(IAmazonSQS sqs, string prefix, string endpointName)
{
var queueName = $"{prefix}{endpointName}";
var getQueueUrlRequest = new GetQueueUrlRequest(queueName);
var queueUrlResponse = await sqs.GetQueueUrlAsync(getQueueUrlRequest).ConfigureAwait(false);
return(queueUrlResponse.QueueUrl);
}
public async Task <GetQueueUrlResponse> GetQueueUrl()
{
var request = new GetQueueUrlRequest
{
QueueName = _QueueName,
};
return(await _AmazonSQSClient.GetQueueUrlAsync(request));
}
/// <summary>
/// Creates the queue with the given name
/// </summary>
public void CreateQueue(string address)
{
m_log.Info("Creating queue {queueName} on region {regionEndpoint}", address, m_AmazonInternalSettings.AmazonSqsConfig.RegionEndpoint);
var amazonSqsConfig = m_AmazonInternalSettings.AmazonSqsConfig;
var awsCredentials = m_AmazonInternalSettings.AmazonCredentialsFactory.Create();
using (var client = new AmazonSQSClient(awsCredentials, amazonSqsConfig))
{
var queueName = GetQueueNameFromAddress(address);
// Check if queue exists
try
{
var request = new GetQueueUrlRequest(queueName);
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSGetQueueUrlRequest.html for options
var getQueueUrlTask = client.GetQueueUrlAsync(request);
AsyncHelpers.RunSync(() => getQueueUrlTask);
var getQueueUrlResponse = getQueueUrlTask.Result;
if (getQueueUrlResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not check for existing queue '{queueName}' - got HTTP {getQueueUrlResponse.HttpStatusCode}");
}
var visibilityTimeout = ((int)m_AmazonInternalSettings.AmazonPeekLockDuration.PeekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture);
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSSetQueueAttributesRequest.html for options
var setAttributesTask = client.SetQueueAttributesAsync(getQueueUrlResponse.QueueUrl, new Dictionary <string, string> {
["VisibilityTimeout"] = visibilityTimeout
});
AsyncHelpers.RunSync(() => setAttributesTask);
var setAttributesResponse = setAttributesTask.Result;
if (setAttributesResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not set attributes for queue '{queueName}' - got HTTP {setAttributesResponse.HttpStatusCode}");
}
}
catch (QueueDoesNotExistException)
{
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSCreateQueueRequest.html for options
var createQueueRequest = new CreateQueueRequest(queueName)
{
Attributes = { ["VisibilityTimeout"] = ((int)m_AmazonInternalSettings.AmazonPeekLockDuration.PeekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture) }
};
var task = client.CreateQueueAsync(createQueueRequest);
AsyncHelpers.RunSync(() => task);
var response = task.Result;
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not create queue '{queueName}' - got HTTP {response.HttpStatusCode}");
}
}
}
}
public Task <GetQueueUrlResponse> GetQueueUrlAsync(
GetQueueUrlRequest request,
CancellationToken cancellationToken = new CancellationToken())
{
return(Task.FromResult(new GetQueueUrlResponse
{
QueueUrl = $"https://testqueues.com/{request.QueueName}"
}));
}
public Task <GetQueueUrlResponse> GetQueueUrl(string QueueName, string OwnerId)
{
var request = new GetQueueUrlRequest
{
QueueName = QueueName,
QueueOwnerAWSAccountId = OwnerId
};
return(_client.GetQueueUrlAsync(request));
}
public AmazonMessageQueueProvider(MainWindowViewModel parentViewModel, CancellationToken ct)
{
_parentViewModel = parentViewModel;
_sqsClient = new AmazonSQSClient();
var queueUrlRequest = new GetQueueUrlRequest("Messenger.fifo");
_queueUrl = _sqsClient.GetQueueUrl(queueUrlRequest).QueueUrl;
Task.Factory.StartNew(GetMessages, ct);
}
/// <summary>
/// Creates the queue with the given name
/// </summary>
public void CreateQueue(string address)
{
if (!_options.CreateQueues)
{
return;
}
_log.Info("Creating queue {queueName}", address);
var queueName = GetQueueNameFromAddress(address);
AsyncHelpers.RunSync(async() =>
{
// Check if queue exists
try
{
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSGetQueueUrlRequest.html for options
var request = new GetQueueUrlRequest(queueName);
var response = await _client.GetQueueUrlAsync(request);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not check for existing queue '{queueName}' - got HTTP {response.HttpStatusCode}");
}
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSSetQueueAttributesRequest.html for options
var setAttributesResponse = await _client.SetQueueAttributesAsync(response.QueueUrl, new Dictionary <string, string>
{
["VisibilityTimeout"] = ((int)_peekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture)
});
if (setAttributesResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not set attributes for queue '{queueName}' - got HTTP {setAttributesResponse.HttpStatusCode}");
}
}
catch (QueueDoesNotExistException)
{
// See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSCreateQueueRequest.html for options
var createQueueRequest = new CreateQueueRequest(queueName)
{
Attributes =
{
["VisibilityTimeout"] = ((int)_peekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture)
}
};
var response = await _client.CreateQueueAsync(createQueueRequest);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Could not create queue '{queueName}' - got HTTP {response.HttpStatusCode}");
}
}
});
}
private async Task <string> GetQueueUrl()
{
var request = new GetQueueUrlRequest
{
QueueName = "mandia-queue",
QueueOwnerAWSAccountId = "341189667252"
};
var response = await sqsClient.GetQueueUrlAsync(request);
return(response.QueueUrl);
}
static void GetUrl(AmazonSQSClient client)
{
var request = new GetQueueUrlRequest
{
QueueName = "EventCollectQueue",
QueueOwnerAWSAccountId = "468917192189"
};
var response = client.GetQueueUrlAsync(request).Result;
Console.WriteLine("res: " + response.QueueUrl);
}
/// <summary>
/// Retrieve the queue URL for the queue named in the queueName
/// property using the client object.
/// </summary>
/// <param name="client">The Amazon SQS client used to retrieve the
/// queue URL.</param>
/// <param name="queueName">A string representing name of the queue
/// for which to retrieve the URL.</param>
/// <returns>The URL of the queue.</returns>
public static async Task <string> GetQueueUrl(IAmazonSQS client, string queueName)
{
var request = new GetQueueUrlRequest
{
QueueName = queueName,
};
GetQueueUrlResponse response = await client.GetQueueUrlAsync(request);
return(response.QueueUrl);
}
public async Task <ActionResult> DeleteQueue(string queueName)
{
GetQueueUrlRequest getQueueUrlRequest = new GetQueueUrlRequest(queueName);
GetQueueUrlResponse getUrlResponse = await _amazonSQS.GetQueueUrlAsync(getQueueUrlRequest);
DeleteQueueRequest deleteQueueRequest = new DeleteQueueRequest(getUrlResponse.QueueUrl);
var response = await _amazonSQS.DeleteQueueAsync(deleteQueueRequest);
return(Ok($"Queue {queueName} is deleted"));
}
public IRequestContext Marshall(GetQueueUrlRequest input)
{
IRequestContext context = new RequestContext();
context.AddParametr("Action", input.ActionName);
context.AddParametr("Version", YandexMqConfig.DEFAULT_SERVICE_VERSION);
context.AddParametr("QueueName", input.QueueName);
return(context);
}
public async Task SendMessageToForroLevelSQS(ForroLevel forroLevel)
{
var request = new GetQueueUrlRequest(_forroLevelQueueName);
var response = await _amazonSQSClient.GetQueueUrlAsync(request);
var newForroLevelJson = JsonConvert.SerializeObject(forroLevel);
var sendMessageRequest = new SendMessageRequest(response.QueueUrl, newForroLevelJson);
var result = await _amazonSQSClient.SendMessageAsync(sendMessageRequest);
}
public string GetQueueUrl(string queueName)
{
var request = new GetQueueUrlRequest
{
QueueName = MailerQueueName,
QueueOwnerAWSAccountId = QueueOwnerAccountId
};
var getQueueUrlResponse = _sqsClient.GetQueueUrl(request);
return(getQueueUrlResponse.HttpStatusCode.Equals(HttpStatusCode.OK) ? getQueueUrlResponse.QueueUrl : string.Empty);
}
private static async Task <string> GetQueueUrl(IAmazonSQS sqs, string qName)
{
var sqsRequest = new GetQueueUrlRequest
{
QueueName = qName,
//QueueOwnerAWSAccountId = AWS_ACCOUNT_ID
};
var createQueueResponse = await sqs.GetQueueUrlAsync(sqsRequest);
Console.WriteLine(createQueueResponse.QueueUrl);
return(createQueueResponse.QueueUrl);
}
public void GetQueueUrlExample()
{
AmazonSQSClient client = new AmazonSQSClient();
var request = new GetQueueUrlRequest
{
QueueName = "SQS_QUEUE_NAME"
};
GetQueueUrlResponse response = client.GetQueueUrl(request);
Console.WriteLine("The SQS queue's URL is {1}", response.QueueUrl);
}
