/// <summary>
/// A simple function to log SNS messages into CloudWatch
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
public void FunctionLogHandler(SNSEvent snsEvent, ILambdaContext context)
{
foreach (var record in snsEvent.Records)
{
context.Logger.LogLine(record.Sns.Message);
}
}
public async Task TestSQSEventLambdaFunction()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage()
{
Message = "foobar"
}
}
}
};
var logger = new TestLambdaLogger();
var context = new TestLambdaContext
{
Logger = logger
};
var function = new Function();
await function.FunctionHandler(snsEvent, context);
Assert.Contains("Processed record foobar", logger.Buffer.ToString());
}
protected virtual async Task PreparePubSubMessage(SNSEvent sns)
{
LambdaLogger.Log($"Starting to process {sns.Records.Count} SNS records...");
foreach (var record in sns.Records)
{
if (!record.Sns.MessageAttributes.ContainsKey(Constants.PubSubBucket))
{
continue;
}
LambdaLogger.Log($"The records message attributes contains key {Constants.PubSubBucket}");
var bucket = record.Sns.MessageAttributes[Constants.PubSubBucket].Value;
var key = record.Sns.MessageAttributes[Constants.PubSubKey].Value;
var s3Response = await _s3Client.GetObjectAsync(bucket, key);
var json = await ReadStream(s3Response.ResponseStream);
var snsEvent = JsonConvert.DeserializeObject <SNSMessage>(json);
record.Sns.Message = snsEvent.Message;
LambdaLogger.Log("Adding SNS message attributes to record");
foreach (var attribute in snsEvent.MessageAttributes)
{
if (!record.Sns.MessageAttributes.ContainsKey(attribute.Key))
{
record.Sns.MessageAttributes.Add(attribute.Key, attribute.Value);
}
}
if (record.Sns.MessageAttributes.Any())
{
LambdaLogger.Log($"mathem.env:sns.message_attributes:{string.Join(",", record.Sns.MessageAttributes.SelectMany(p => $"{p.Key}={p.Value?.Value?.Replace("=", "%3D")}"))}");
}
}
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an SQS event object and can be used
/// to respond to SQS messages.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
foreach (var message in evnt.Records)
{
await ProcessMessageAsync(message, context);
}
}
public virtual UpdateTargetsRequest CreateFromSnsEvent(SNSEvent evnt)
{
var message = Deserialize <AlarmEvent>(evnt.Records[0].Sns.Message);
var request = new UpdateTargetsRequest();
foreach (var metric in message.Trigger.Metrics)
{
if (metric.Id != "customdata")
{
continue;
}
foreach (var dimension in metric.MetricStat.Metric.Dimensions)
{
switch (dimension.Name)
{
case "TargetGroupArn": request.TargetGroupArn = dimension.Value; break;
case "TargetDnsName": request.TargetDnsName = dimension.Value; break;
default: break;
}
}
}
return(request);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(SNSEvent snsEvent, ILambdaContext context)
{
foreach (var record in snsEvent.Records)
{
var snsRecord = record.Sns;
Console.WriteLine($"[{record.EventSource} {snsRecord.Timestamp}] Message = {snsRecord.Message}");
if (snsRecord.Message != null && !string.IsNullOrEmpty(snsRecord.Message))
{
var serialize = new JsonSerializer();
using (var reader = new JsonTextReader(new StringReader(snsRecord.Message)))
{
var ddbTable = serialize.Deserialize <TableDescription>(reader);
var code = FromDDBTableModel(ddbTable);
var bucketName = System.Environment.GetEnvironmentVariable(BUCKET_NAME_KEY);
if (string.IsNullOrEmpty(bucketName))
{
throw new Exception("Couldn't find S3 bucket");
}
var client = new AmazonS3Client();
var response = await client.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
ContentBody = code,
Key = $"{GetClassName(ddbTable)}.cs"
});
System.Console.WriteLine(response.HttpStatusCode);
System.Console.WriteLine(response.ETag);
System.Console.WriteLine(response.VersionId);
}
}
}
}
public async Task TestSQSEventLambdaFunction()
{
var sesNotificationMessage = File.ReadAllText(@"TestMessages\BounceWithDsn.json");
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage()
{
Message = sesNotificationMessage
}
}
}
};
var logger = new TestLambdaLogger();
var context = new TestLambdaContext
{
Logger = logger
};
var function = new Function();
await function.FunctionHandler(snsEvent, context);
Assert.Contains("Processed record for Bounce", logger.Buffer.ToString());
}
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
// ### Level 1 - Create New Trail and Configure Lambda
context.Logger.LogLine(JsonConvert.SerializeObject(evnt));
// ### Level 2 - Retrieve Logs from S3
var snsMessage = JsonConvert.DeserializeObject <S3Data>(evnt.Records[0].Sns.Message);
String s3Bucket = snsMessage.s3Bucket;
String s3ObjectKey = snsMessage.s3ObjectKey[0];
context.Logger.LogLine(s3Bucket);
context.Logger.LogLine(s3ObjectKey);
GetObjectRequest request = new GetObjectRequest {
BucketName = s3Bucket,
Key = s3ObjectKey
};
var response = await S3Client.GetObjectAsync(request);
using (Stream reader = response.ResponseStream) {
var bytes = ReadStream(reader);
await ExtractCloudTrailRecordsAsync(context.Logger, bytes);
}
// ### Level 3 - Filter for specific events and send alerts
// ### Boss level - Take mitigating action
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an SNS event object and can be used
/// to respond to SNS messages.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
foreach (var record in evnt.Records)
{
await ProcessRecordAsync(record, context);
}
}
public async Task ShouldPublishMessagesWithIdsToSQS(
SNSEvent snsEvent,
SNSEvent.SNSRecord record1,
SNSEvent.SNSRecord record2,
Request request1,
Request request2,
[Frozen] IAmazonSQS sqs,
[Frozen] ISnsRecordMapper mapper,
[Target] Handler handler,
CancellationToken cancellationToken
)
{
snsEvent.Records = new List <SNSEvent.SNSRecord> {
record1, record2
};
mapper.MapToRequest(Is(record1)).Returns(request1);
mapper.MapToRequest(Is(record2)).Returns(request2);
await handler.Handle(snsEvent, cancellationToken);
await sqs.Received().SendMessageBatchAsync(Any <SendMessageBatchRequest>(), Is(cancellationToken));
var request = TestUtils.GetArg <SendMessageBatchRequest>(sqs, nameof(IAmazonSQS.SendMessageBatchAsync), 0);
request.Entries.Should().Contain(entry => entry.Id == request1.Id.ToString());
request.Entries.Should().Contain(entry => entry.Id == request2.Id.ToString());
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(SNSEvent snsEvent, ILambdaContext context)
{
foreach (var snsEventRecord in snsEvent.Records)
{
await ProcessSnsEvent(snsEventRecord, context);
}
}
public void TestFunction()
{
var function = new Function();
var context = new TestLambdaContext();
SNSEvent.SNSMessage snsMessage = new SNSEvent.SNSMessage {
Message = "{\"notificationType\":\"Bounce\",\"bounce\":{\"bounceType\":\"Permanent\",\"feedbackId\":\"feedback_id\",\"bouncedRecipients\":[{\"emailAddress\":\"[email protected]\"}]}}",
Timestamp = DateTime.Parse("1/1/1990")
};
SNSEvent.SNSRecord snsRecord = new SNSEvent.SNSRecord {
EventSource = "event_source",
EventSubscriptionArn = "event_subscription_arn",
EventVersion = "event_version",
Sns = snsMessage
};
List <SNSEvent.SNSRecord> recordList = new List <SNSEvent.SNSRecord>();
recordList.Add(snsRecord);
SNSEvent snsEvent = new SNSEvent {
Records = recordList
};
var retval = function.FunctionHandler(snsEvent, context);
Assert.Equal("okay", retval.Result);
}
public async Task HandleAsync_resolves_NotificationHandler_for_each_record()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var lambdaContext = new TestLambdaContext();
var sut = CreateSystemUnderTest();
await sut.HandleAsync(snsEvent, lambdaContext);
mockServiceProvider.Verify(p => p.GetService(typeof(INotificationHandler <TestNotification>)), Times.Exactly(snsEvent.Records.Count));
}
public Task Before(SNSEvent snsEvent, MiddyNetContext context)
{
var snsMessage = snsEvent.Records.First().Sns;
var traceParentHeaderValue = string.Empty;
if (snsMessage.MessageAttributes.ContainsKey(TraceParentHeaderName))
{
traceParentHeaderValue = snsMessage.MessageAttributes[TraceParentHeaderName].Value;
}
var traceStateHeaderValue = string.Empty;
if (snsMessage.MessageAttributes.ContainsKey(TraceStateHeaderName))
{
traceParentHeaderValue = snsMessage.MessageAttributes[TraceStateHeaderName].Value;
}
var traceContext = TraceContext.Handle(traceParentHeaderValue, traceStateHeaderValue);
context.Logger.EnrichWith(new LogProperty(TraceParentHeaderName, traceContext.TraceParent));
context.Logger.EnrichWith(new LogProperty(TraceStateHeaderName, traceContext.TraceState));
context.Logger.EnrichWith(new LogProperty(TraceIdHeaderName, traceContext.TraceId));
return(Task.CompletedTask);
}
public async Task HandleAsync_creates_a_scope_for_each_record()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var lambdaContext = new TestLambdaContext();
var sut = CreateSystemUnderTest();
await sut.HandleAsync(snsEvent, lambdaContext);
mockServiceScopeFactory.Verify(p => p.CreateScope(), Times.Exactly(snsEvent.Records.Count));
}
public async Task HandleAsync_executes_NotificationHandler_for_each_record()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var lambdaContext = new TestLambdaContext();
var sut = CreateSystemUnderTest();
await sut.HandleAsync(snsEvent, lambdaContext);
mockNotificationHandler.Verify(p => p.HandleAsync(It.IsAny <TestNotification>(), lambdaContext), Times.Exactly(snsEvent.Records.Count));
}
public void HandleAsync_throws_InvalidOperation_if_NotificationHandler_is_not_registered()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var lambdaContext = new TestLambdaContext();
mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider.Setup(p => p.GetService(typeof(IServiceScopeFactory))).Returns(mockServiceScopeFactory.Object);
mockServiceScope.Setup(p => p.ServiceProvider).Returns(mockServiceProvider.Object);
var sut = CreateSystemUnderTest();
Assert.ThrowsAsync <InvalidOperationException>(() => sut.HandleAsync(snsEvent, lambdaContext));
}
public async Task TestEmailSending()
{
var message = new SNSEvent
{
Records = new List <SNSRecord> {
new SNSRecord()
}
};
var request = new SendEmailSNSRequest
{
From = "*****@*****.**",
To = new List <string> {
"*****@*****.**"
},
Body = "test",
Subject = "Test",
HtmlBody = "",
FromName = "Rahul"
};
var context = new TestLambdaContext();
message.Records[0].Sns.Message = Newtonsoft.Json.JsonConvert.SerializeObject(request);
var lambda = new NotificationFunction();
var response = await lambda.TriggerEmailAsync(message, context);
Assert.NotNull(response);
}
public async Task TestDistributor()
{
// ARRANGE
TestLambdaLogger testLogger = new TestLambdaLogger();
TestClientContext clientContext = new TestClientContext();
TestLambdaContext context = new TestLambdaContext()
{
FunctionName = "PriceListApiFormatter",
FunctionVersion = "1",
Logger = testLogger,
ClientContext = clientContext
};
SNSEvent ev = new SNSEvent();
Mock <IAmazonS3> s3 = new Mock <IAmazonS3>();
Mock <IAmazonLambda> lambda = new Mock <IAmazonLambda>();
Mock <IAmazonSimpleNotificationService> sns = new Mock <IAmazonSimpleNotificationService>();
lambda.Setup(x => x.InvokeAsync(It.IsAny <InvokeRequest>(), default(CancellationToken))).Returns(Task.FromResult(new InvokeResponse()));
Entrypoint entry = new Entrypoint(sns.Object, s3.Object, lambda.Object);
// ACT
await entry.LaunchWorkersAsync(ev, context);
// ASSERT
}
public async Task SendEmail(SNSEvent input)
{
foreach (var notification in input.Records)
{
var emailNotification = JsonConvert.DeserializeObject <EmailNotification>(notification.Sns.Message);
await _emailSender.SendEmail(emailNotification.Key, emailNotification.Email);
}
}
public static string FunctionHandler(SNSEvent input, ILambdaContext context)
{
foreach (var item in input.Records)
{
}
return("Task done.");
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public void FunctionHandler(SNSEvent snsEvent, ILambdaContext context)
{
foreach (var record in snsEvent.Records)
{
var snsRecord = record.Sns;
LambdaLogger.Log($"[{record.EventSource} {snsRecord.Timestamp}] Message = {snsRecord.Message}, Message ID = {snsRecord.MessageId}");
}
}
private static void Handle(SNSEvent snsEvent)
{
foreach (var record in snsEvent.Records)
{
var snsRecord = record.Sns;
Console.WriteLine($"[{record.EventSource} {snsRecord.Timestamp}] Message = {snsRecord.Message}");
}
}
public async Task <string> Transcode(SNSEvent s3event, ILambdaContext context)
{
var sourceFile = s3event.Records.First().Sns.Message;
context.Logger.LogLine(sourceFile);
return(await _transcoder.Transcode(sourceFile, context.Logger));
}
public async Task <Response> ProcessSms(SNSEvent snsEvent)
{
if (snsEvent == null)
{
Console.WriteLine("Empty snsEvent object!");
return(null);
}
foreach (var record in snsEvent.Records)
{
var snsRecord = record.Sns;
Console.WriteLine($"[{record.EventSource} {snsRecord.Timestamp}] Message = {snsRecord.Message}");
dynamic reply = JValue.Parse(snsRecord.Message);
var smsResponse = new SMSMessage
{
MessageType = MessageType,
OriginationNumber = originationNumber,
SenderId = SenderId,
Keyword = RegisteredKeyword
};
string destinationNumber = reply.originationNumber;
string incomingBody = reply.messageBody;
if (incomingBody.IndexOf(' ') <= 0)
{
smsResponse.Body = DefaultMessage;
await SendReplyToSender(smsResponse, destinationNumber);
return(null);
}
string prefix = incomingBody.Substring(0, incomingBody.IndexOf(' '));
switch (prefix.ToUpper())
{
case "REPORT":
string reportId = incomingBody.Substring(7);
smsResponse.Body = GetReport(reportId).Result;
break;
case "ECHO":
smsResponse.Body = incomingBody.Substring(5);
break;
default:
smsResponse.Body = DefaultMessage;
break;
}
await SendReplyToSender(smsResponse, destinationNumber);
}
return(null);
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an SNS event object and can be used
/// to respond to SNS messages.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <string> FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
foreach (var record in evnt.Records)
{
await ProcessRecordAsync(record, context);
}
return("done");
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an SNS event object and can be used
/// to respond to SNS messages.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
context.Logger.LogLine($"Received new event with {evnt.Records.Count} records.");
foreach (var record in evnt.Records)
{
await ProcessRecordAsync(record, context);
}
}
public void SnsEventHandler(SNSEvent snsEvent)
{
snsEvent.Records.ToList().ForEach(x =>
{
Console.WriteLine($"Message received: {x.Sns.Message}");
var weatherEvent = JsonSerializer.Deserialize <WeatherEvent>(x.Sns.Message);
LogEvent(weatherEvent);
});
}
/// <summary>
/// Function to carry out Basket item status update on SNS event.
/// </summary>
/// <param name="snsEvent"></param>
public async Task SNSHandler(SNSEvent snsEvent)
{
foreach (var record in snsEvent.Records)
{
var snsRecord = record.Sns;
var unicornAvailableMessage = JsonConvert.DeserializeObject <SNSMessage>(snsRecord.Message);
await this.dynamoDBService.UpdateItemAvailability(unicornAvailableMessage.unicorn_id, unicornAvailableMessage.available);
}
}
public async Task EventHandler_Should_Use_Scoped_Object_In_ForEachAsync_Loop()
{
var snsEvent = new SNSEvent
{
Records = new List <SNSEvent.SNSRecord>
{
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
},
new SNSEvent.SNSRecord
{
Sns = new SNSEvent.SNSMessage
{
Message = "{}"
}
}
}
};
var dependency = new DisposableDependency();
var services = new ServiceCollection();
services.AddScoped(_ => dependency);
var tcs = new TaskCompletionSource <TestNotification>();
services.AddTransient <IEventHandler <SNSEvent>, ParallelSnsEventHandler <TestNotification> >();
services.AddTransient <INotificationHandler <TestNotification>,
TestNotificationScopedHandler>(provider => new TestNotificationScopedHandler(provider.GetRequiredService <DisposableDependency>(), tcs));
services.AddSingleton <ISerializer, SystemTextJsonSerializer>();
var sp = services.BuildServiceProvider();
var serializer = sp.GetRequiredService <ISerializer>();
var sqsEventHandler = new ParallelSnsEventHandler <TestNotification>(sp, serializer, new NullLoggerFactory(), Options.Create(new ParallelSnsExecutionOptions {
MaxDegreeOfParallelism = 4
}));
var task = sqsEventHandler.HandleAsync(snsEvent, new TestLambdaContext());
Assert.That(dependency.Disposed, Is.False, "Dependency should not be disposed");
Assert.That(task.IsCompleted, Is.False, "The task should not be completed");
tcs.SetResult(new TestNotification());
await task;
Assert.That(dependency.Disposed, Is.True, "Dependency should be disposed");
Assert.That(task.IsCompleted, Is.True, "The task should be completed");
}
