public async Task ReadMessageAsync()
{
var queueName = "local-reader-read-message-test-" + DateTime.Now.Ticks;
using (var client = new AmazonSQSClient(TestUtils.GetAWSCredentials(), TestUtils.TestRegion))
{
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = queueName });
await TestUtils.WaitTillQueueIsCreatedAsync(client, createResponse.QueueUrl);
try
{
var manager = new ExternalCommandManager();
var message = manager.ReadMessage(TestUtils.TestProfile, TestUtils.TestRegion.SystemName, createResponse.QueueUrl);
Assert.Null(message);
await client.SendMessageAsync(new SendMessageRequest
{
MessageBody = "data",
QueueUrl = createResponse.QueueUrl
});
message = manager.ReadMessage(TestUtils.TestProfile, TestUtils.TestRegion.SystemName, createResponse.QueueUrl);
Assert.NotNull(message);
manager.DeleteMessage(TestUtils.TestProfile, TestUtils.TestRegion.SystemName, createResponse.QueueUrl, message.ReceiptHandle);
}
finally
{
await client.DeleteQueueAsync(createResponse.QueueUrl);
}
}
}
public IndexModel(LocalLambdaOptions lambdaOptions)
{
this.LambdaOptions = lambdaOptions;
var externalManager = new ExternalCommandManager();
this.AWSProfiles = externalManager.ListProfiles();
}
public void ListProfiles()
{
var manager = new ExternalCommandManager();
var profiles = manager.ListProfiles();
Assert.NotEmpty(profiles);
foreach (var profile in profiles)
{
Assert.False(string.IsNullOrWhiteSpace(profile));
}
Assert.True(profiles.Contains(TestUtils.TestProfile));
}
public IList <QueueItem> ListAvailableQueuesAsync(string awsProfile, string awsRegion)
{
var manager = new ExternalCommandManager();
var queueUrls = manager.ListQueues(awsProfile, awsRegion);
var items = new List <QueueItem>();
foreach (var queueUrl in queueUrls)
{
items.Add(new QueueItem {
QueueUrl = queueUrl
});
}
return(items);
}
public async Task ListQueuesAsync()
{
var queueName = "local-reader-list-queue-test-" + DateTime.Now.Ticks;
using (var client = new AmazonSQSClient(TestUtils.GetAWSCredentials(), TestUtils.TestRegion))
{
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = queueName });
await TestUtils.WaitTillQueueIsCreatedAsync(client, createResponse.QueueUrl);
try
{
var manager = new ExternalCommandManager();
var queues = manager.ListQueues(TestUtils.TestProfile, TestUtils.TestRegion.SystemName);
Assert.True(queues.Contains(createResponse.QueueUrl));
}
finally
{
await client.DeleteQueueAsync(createResponse.QueueUrl);
}
}
}
public void PurgeDlq([FromBody] PurgeDlqModel model)
{
var manager = new ExternalCommandManager();
manager.PurgeQueue(model.Profile, model.Region, model.QueueUrl);
}
private void Loop(CancellationToken token)
{
var manager = new ExternalCommandManager();
while (!token.IsCancellationRequested)
{
SQSMessage message = null;
LogRecord logRecord = null;
try
{
// Read a message from the queue using the ExternalCommands console application.
message = manager.ReadMessage(this._profile, this._region, this._queueUrl);
if (token.IsCancellationRequested)
{
return;
}
if (message == null)
{
// Since there are no messages, sleep a bit to wait for messages to come.
Thread.Sleep(1000);
continue;
}
// If a message was received execute the Lambda function within the test tool.
var request = new ExecutionRequest
{
AWSProfile = this._profile,
AWSRegion = this._region,
Function = this._function,
Payload = message.Body
};
var response = this._runtime.ExecuteLambdaFunction(request);
// Capture the results to send back to the client application.
logRecord = new LogRecord
{
ProcessTime = DateTime.Now,
ReceiptHandle = message.ReceiptHandle,
Logs = response.Logs,
Error = response.Error
};
}
catch (Exception e)
{
logRecord = new LogRecord
{
ProcessTime = DateTime.Now,
Error = e.Message
};
Thread.Sleep(1000);
}
if (logRecord != null && message != null)
{
logRecord.Event = message.Body;
}
lock (LOG_LOCK)
{
this._records.Add(logRecord);
}
}
}
