Esempio n. 1
0
        public async Task TestS3EventLambdaFunction()
        {
            // Setup the S3 event object that S3 notifications would create with the
            // fields used by the Lambda function.
            var s3Event = new S3Event
            {
                Records = new List <S3EventNotificationRecord>
                {
                    new S3EventNotificationRecord
                    {
                        AwsRegion = "eu-west-1",
                        S3        = new S3Entity
                        {
                            Bucket = new S3BucketEntity {
                                Name = BucketName
                            },
                            Object = new S3ObjectEntity {
                                Key = Key
                            }
                        }
                    }
                }
            };

            // Invoke the lambda function and confirm the content type was returned.
            var function = new Function(new OptimizerStub());
            var result   = await function.FunctionHandler(s3Event, null);

            var imageUrl      = $"https://s3.eu-west-1.amazonaws.com/{BucketName}/{Key}";
            var optimizedSlug = "optimized-images/jake-the-dog.png";
            var expected      = $"{imageUrl} <> {optimizedSlug}";

            Assert.Equal(expected, result);
        }
Esempio n. 2
0
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var response = await this.S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

                Console.WriteLine(s3Event.Bucket.Name.ToString());
                Console.WriteLine(s3Event.Object.Key.ToString());
                await ProcessTranscribe(s3Event.Bucket.Name, s3Event.Object.Key);

                return(response.Headers.ContentType);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
                throw;
            }
        }
 public BulkEventLambdaFunctionalTests()
 {
     _fakeS3Event = new S3Event()
     {
         Records = new List <S3EventNotification.S3EventNotificationRecord>
         {
             new S3EventNotification.S3EventNotificationRecord
             {
                 S3 = new S3EventNotification.S3Entity
                 {
                     Bucket = new S3EventNotification.S3BucketEntity
                     {
                         Name = "fakeBucket"
                     },
                     Object = new S3EventNotification.S3ObjectEntity
                     {
                         Key = "fakeKey"
                     }
                 }
             }
         }
     };
     _fakeSns            = A.Fake <AmazonSimpleNotificationServiceClient>();
     _fakeS3             = A.Fake <AmazonS3Client>();
     _s3GetObjectRequest = new GetObjectRequest()
     {
         BucketName = "fakeBucket",
         Key        = "fakeKey"
     };
     _snsTopic = "test-topic";
 }
Esempio n. 4
0
    /// <summary>
    /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
    /// to respond to S3 notifications.
    /// </summary>
    /// <param name="evnt"></param>
    /// <param name="context"></param>
    /// <returns></returns>
    public async Task <string?> FunctionHandler(S3Event evnt, ILambdaContext context)
    {
        Console.WriteLine("Hello world");
        Console.WriteLine(JsonSerializer.Serialize(evnt));

        var s3Event = evnt.Records?[0].S3;

        if (s3Event == null)
        {
            return(null);
        }

        try
        {
            var response = await this.S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

            Console.WriteLine(JsonSerializer.Serialize(await GetLatestWilburWednesday()));
            var latestWilbur = await GetLatestWilburWednesday();
            await SendEmail(new EmailItem(latestWilbur));

            return(response.Headers.ContentType);
        }
        catch (Exception e)
        {
            context.Logger.LogInformation($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
            context.Logger.LogInformation(e.Message);
            context.Logger.LogInformation(e.StackTrace);
            throw;
        }
    }
Esempio n. 5
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        //public async Task<string> FunctionHandler(S3Event events, ILambdaContext context)
        public async Task FunctionHandler(S3Event events, ILambdaContext context)
        {
            foreach (var evnt in events.Records)
            {
                var s3Event = evnt.S3;
                if (s3Event == null)
                {
                    return;
                }

                context.Logger.LogLine($"Received notification of {evnt.EventName} for s3://{s3Event.Bucket.Name}/{s3Event.Object.Key}");

                // create some random temperature forecasts
                StringBuilder bld = new StringBuilder();
                Random        r   = new Random();
                for (int i = 0; i < 10; i++)
                {
                    int hour    = r.Next(0, 24);
                    int tempInt = r.Next(0, 30);
                    int tempDec = r.Next(0, 9);
                    bld.AppendLine($"2020-09-28 {(hour < 10 ? "0" + hour.ToString() : hour.ToString())}:00:00,{tempInt}.{tempDec}");
                }

                // change the file extension to .csv from .nc
                string newKey = s3Event.Object.Key.Replace(".nc", ".csv");
                context.Logger.LogLine($"Going to write to file s3://bigwind-curated/{newKey} content: {bld}");

                var response = await S3Client.PutObjectAsync(new Amazon.S3.Model.PutObjectRequest()
                {
                    BucketName = "bigwind-curated", Key = newKey, ContentBody = bld.ToString(), ContentType = "text/plain"
                });
            }

            return;
        }
Esempio n. 6
0
        public async Task FunctionHandler(S3Event s3Event, ILambdaContext context)
        {
            foreach (var record in s3Event.Records)
            {
                if (!_supportedImageTypes.Contains(Path.GetExtension(record.S3.Object.Key).ToLower()))
                {
                    Console.WriteLine($"Object {record.S3.Bucket.Name}:{record.S3.Object.Key} is not a supported image type");
                    continue;
                }

                Console.WriteLine($"Determining whether image {record.S3.Bucket.Name}:{record.S3.Object.Key} has been compressed");

                // Get the existing tag set
                var taggingResponse = await _s3Client.GetObjectTaggingAsync(new GetObjectTaggingRequest
                {
                    BucketName = record.S3.Bucket.Name,
                    Key        = record.S3.Object.Key
                });

                if (taggingResponse.Tagging.Any(tag => tag.Key == "Compressed" && tag.Value == "true"))
                {
                    Console.WriteLine($"Image {record.S3.Bucket.Name}:{record.S3.Object.Key} has already been compressed");
                    continue;
                }

                // Get the existing image
                using (var objectResponse = await _s3Client.GetObjectAsync(record.S3.Bucket.Name, record.S3.Object.Key))
                    using (Stream responseStream = objectResponse.ResponseStream)
                    {
                        Console.WriteLine($"Compressing image {record.S3.Bucket.Name}:{record.S3.Object.Key}");

                        // Use TinyPNG to compress the image
                        TinyPngClient tinyPngClient    = new TinyPngClient(Environment.GetEnvironmentVariable("TinyPNG_API_Key"));
                        var           compressResponse = await tinyPngClient.Compress(responseStream);

                        var downloadResponse = await tinyPngClient.Download(compressResponse);

                        // Upload the compressed image back to S3
                        using (var compressedStream = await downloadResponse.GetImageStreamData())
                        {
                            Console.WriteLine($"Uploading compressed image {record.S3.Bucket.Name}:{record.S3.Object.Key}");

                            await _s3Client.PutObjectAsync(new PutObjectRequest
                            {
                                BucketName  = record.S3.Bucket.Name,
                                Key         = record.S3.Object.Key,
                                InputStream = compressedStream,
                                TagSet      = new List <Tag>
                                {
                                    new Tag
                                    {
                                        Key   = "Compressed",
                                        Value = "true"
                                    }
                                }
                            });
                        }
                    }
            }
        }
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public string FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return("Empty event");
            }
            try
            {
                bktKey = s3Event.Object.Key;
                context.Logger.LogLine($"Getting object {s3Event.Object.Key} from bucket: {s3Event.Bucket.Name}.");

                ProcessObjectDataAsync(context).Wait();
                context.Logger.LogLine($"Returned from data processing");
                //GetObjectMetadataRequest mdReq = new GetObjectMetadataRequest
                //{
                //    BucketName = s3Event.Bucket.Name,
                //    Key = s3Event.Object.Key,
                //};
                //var response = await this.S3Client.GetObjectMetadataAsync(mdReq);

                return("Success");
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                return("Exception");
            }
        }
Esempio n. 8
0
        /// <summary>
        ///     This method is called for every Lambda invocation. This method takes in an S3 event object and can be used to respond to S3 notifications.
        /// </summary>
        /// <param name="input"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task Handler(S3Event input, ILambdaContext context)
        {
            var key = input.Records?[0].S3.Object.Key;

            var sourceKey = WebUtility.UrlDecode(key);

            var outputKey = sourceKey.Split('.')[0];

            context.Logger.LogLine($"key: {key}, sourceKey: {sourceKey}, outputKey: {outputKey}");

            var job = new CreateJobRequest
            {
                PipelineId      = "1505766337361-sv0ahs",
                OutputKeyPrefix = $"{outputKey}/",
                Input           = new JobInput {
                    Key = sourceKey
                },
                Outputs = new List <CreateJobOutput>(new[]
                {
                    new CreateJobOutput {
                        Key = $"{outputKey}-1080p.mp4", PresetId = "1351620000001-000001"
                    },
                    new CreateJobOutput {
                        Key = $"{outputKey}-720p.mp4", PresetId = "1351620000001-000010"
                    },
                    new CreateJobOutput {
                        Key = $"{outputKey}-web-720p.mp4", PresetId = "1351620000001-100070"
                    }
                })
            };

            await _elasticTranscoder.CreateJobAsync(job);
        }
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task ExecuteAsync(S3Event evnt, ILambdaContext context)
        {
            try
            {
                var s3Event     = evnt.Records?[0].S3;
                var getResponse = await GetS3Object(s3Event.Bucket.Name, s3Event.Object.Key);

                using (var responseStream = getResponse.ResponseStream)
                {
                    using (var resizedStream = GetResizedStream(responseStream, 0.2m, getResponse.Headers.ContentType))
                    {
                        resizedStream.Seek(0, SeekOrigin.Begin);
                        await WriteS3Object(
                            System.Environment.GetEnvironmentVariable("ThumbnailBucketName", EnvironmentVariableTarget.Process),
                            $"thumb_{s3Event.Object.Key}",
                            resizedStream);
                    }
                }

                context.Logger.LogLine("Operation Complete");
            }
            catch (Exception ex)
            {
                context.Logger.LogLine(ex.Message);
            }
        }
Esempio n. 10
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            context.Logger.LogLine("Geppetto.StorageEvents.Function Invoked");

            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var gridEvents = GetEvents(evnt);
                if (gridEvents != null && gridEvents.Count > 0)
                {
                    await PublishEvents(gridEvents);
                }

                return("success");
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 11
0
        private IList <EventGridEvent> GetEvents(S3Event evnt)
        {
            var events = new List <EventGridEvent>();

            foreach (var eventNotification in evnt.Records)
            {
                var s3Event = eventNotification.S3;
                var file    = new AzReplicator.AWS.Models.FileEvent()
                {
                    Name = s3Event.Object.Key,
                    Url  = GeneratePreSignedUrl(s3Event.Bucket.Name, s3Event.Object.Key, this.S3Client)
                };

                events.Add(new EventGridEvent()
                {
                    Id          = Guid.NewGuid().ToString(),
                    Data        = file,
                    EventTime   = DateTime.UtcNow,
                    EventType   = "Geppetto.NewFile",
                    Subject     = s3Event.Object.Key,
                    DataVersion = "1.0"
                });
            }

            return(events);
        }
Esempio n. 12
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <SendMessageResponse> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                SendMessageResponse result;

                using (var response = await S3Client.GetObjectAsync(s3Event.Bucket.Name, s3Event.Object.Key))
                    using (Stream responseStream = response.ResponseStream)
                        using (var reader = new StreamReader(responseStream))
                        {
                            var message = await reader.ReadToEndAsync();

                            result = await SqsClient.SendMessageAsync(_queueUrl, $"New Task Created:\n{message}");
                        }

                return(result);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 13
0
        /// <summary>
        /// Needed initialization before running the main logic of the function
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        private void Initialization(S3Event evnt, ILambdaContext context)
        {
            try
            {
                var s3Event = evnt.Records?[0].S3;
                if (s3Event == null)
                {
                    context.Logger.LogLine("No events detected from S3. Lambda function returns!");
                }

                zipFileName = s3Event.Object.Key;

                context.Logger.LogLine("Zip file " + zipFileName + " detected!");

                zipFileNameWithoutExtension = zipFileName.Substring(0, zipFileName.Length - 4);

                srcBucketName = s3Event.Bucket.Name;

                extractedZipFilePath = dstBucketName + "/" + zipFileNameWithoutExtension;

                tmpExtractPath = "/tmp/" + zipFileNameWithoutExtension;
                tmpFileName    = System.IO.Path.GetTempFileName();
                context.Logger.LogLine("Temp file name: " + tmpFileName);
            }
            catch (Exception e)
            {
                context.Logger.LogLine("Error in Initialization: " + e.Message);
            }
        }
Esempio n. 14
0
        /// <summary>
        /// This method is called when associated S3 bucket has new file and trigger AWS Glue to transform it.
        /// </summary>
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            context.Logger.LogLine("Started!");
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                context.Logger.LogLine("Event not found!");
                return("Event not found!");
            }

            try
            {
                context.Logger.LogLine("Starting job run...");
                await GlueClient.StartJobRunAsync(new StartJobRunRequest()
                {
                    AllocatedCapacity = 2,
                    JobName           = Environment.GetEnvironmentVariable("GLUE_JOB_NAME")
                });

                context.Logger.LogLine("Done");
                return("Done");
            }
            catch (Exception e)
            {
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 15
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> ObjectCreatedHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var record       = evnt.Records?.FirstOrDefault();
                var s3ObjectName = record?.S3?.Object?.Key;
                s3ObjectName = s3ObjectName ?? string.Empty;

                context.Logger.LogLine(string.Format("Lambda funtion {0} - A new object {1} has been created in bucket named {2}  ", context.FunctionName, s3ObjectName, s3Event.Bucket.Name));

                var response = await this.S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

                return(response.Headers.ContentType);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 16
0
        public async Task FunctionHandler(S3Event @event, ILambdaContext context)
        {
            context.Logger.Log("START");

            context.Logger.Log("S3Event: " + JsonConvert.SerializeObject(@event));

            foreach (var record in @event.Records)
            {
                context.Logger.Log($"Processing file {record.S3.Bucket.Name}:{record.S3.Object.Key}.");

                var metadata = await _s3client.GetObjectMetadataAsync(record.S3.Bucket.Name, record.S3.Object.Key);

                context.Logger.Log("Metadata: " + JsonConvert.SerializeObject(metadata));

                if (metadata.Metadata.Keys.Contains(metadataKey))
                {
                    var value = Convert.ToInt32(metadata.Metadata[metadataKey]);

                    context.Logger.Log($"{metadataKey} = {value}");

                    await UpdateDatabase(value, record.S3.Object.Key);
                }
            }

            context.Logger.Log("END");
        }
Esempio n. 17
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var response = await S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

                string message = $"{s3Event.Object.Key} - {s3Event.Object.Size} Bytes";
                context.Logger.LogLine(message);
                PublishRequest request = new PublishRequest
                {
                    Message     = message,
                    PhoneNumber = "+34642375554"
                };

                var smsResponse = await SnsClient.PublishAsync(request);

                context.Logger.LogLine($"Response from SNS: {smsResponse.HttpStatusCode}");
                return(response.Headers.ContentType);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 18
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> S3EventHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                string decodedKey = HttpUtility.UrlDecode(s3Event.Object.Key);
                context.Logger.LogLine($"Reading \"{decodedKey}\"...");
                Stream stream = await S3Client.GetObjectStreamAsync(s3Event.Bucket.Name, decodedKey, null);

                string applicantJSON = ParseDataFromS3(stream, decodedKey);
                context.Logger.LogLine($"\"{decodedKey}\" read\n{applicantJSON}");
                context.Logger.LogLine($"Putting data in DynamoDb Table...");
                await PutDataInDynamoDB(applicantJSON);

                context.Logger.LogLine($"Data put successfully! Check the DynamoDB table for more details.");
                return("Success!");
            }
            catch (Exception e)
            {
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 19
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var response = await this.S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

                context.Logger.LogLine($"S3 Object Key: {s3Event.Object.Key}");
                context.Logger.LogLine(JsonSerializer.Serialize(response));
                return(response.Headers.ContentType);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 20
0
 /// <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(S3Event input, ILambdaContext context)
 {
     foreach (var record in input.Records)
     {
         context.Logger.Log($"Bucket: {record.S3.Bucket.Name}, Key: {record.S3.Object.Key}");
     }
 }
Esempio n. 21
0
        public async Task FunctionHandler(S3Event s3Event, ILambdaContext context)
        {
            var srcBucket = s3Event.Records[0].S3.Bucket;
            var srcObject = s3Event.Records[0].S3.Object;

            using (var s3Service = new AmazonS3Client())
            {
                var incoming = await s3Service.GetObjectAsync(srcBucket.Name, srcObject.Key);

                using (var streamReader = new StreamReader(incoming.ResponseStream))
                {
                    var content = streamReader.ReadToEnd();
                    var payload = new string(content.Reverse().ToArray());

                    var putRequest = new PutObjectRequest
                    {
                        BucketName  = "vinlewt-tx-output",
                        Key         = srcObject.Key,
                        ContentBody = payload
                    };

                    await s3Service.PutObjectAsync(putRequest);
                }
            }
        }
        public async Task RunAsync(S3Event s3Event, ILambdaContext context)
        {
            _logger.LogInformation("Copy Build Triggered: ");
            _logger.LogInformation(s3Event.ToJsonString(true));

            //used by third party zip library
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

            if (s3Event == null || s3Event.Records == null || s3Event.Records.Count <= 0)
            {
                return;
            }

            foreach (var record in s3Event.Records.Where(r => r.S3.Object.Key.ToUpper().Contains("BUILD")))
            {
                var buildBucket = Environment.GetEnvironmentVariable("BUILDBUCKET");
                _logger.LogInformation("Build bucket: " + buildBucket);

                var sourceKey = record.S3.Object.Key;
                _logger.LogInformation($"Source Key: {sourceKey}");

                var solutionName = sourceKey.Substring(0, sourceKey.IndexOf("/"));
                _logger.LogInformation($"Solution: {solutionName}");


                await BuildProcessorFactory.GetBuildProcessor().ProcessBuildAsync(solutionName, sourceKey, record.S3.Bucket.Name, buildBucket);
            }
        }
Esempio n. 23
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> FunctionHandler(S3Event ev, ILambdaContext context)
        {
            try
            {
                IList <FileAddedBusMessage> messages = PrepareMessages(ev);
                if (messages.Count > 0)
                {
                    await _busSender.SendBatch(messages, context.Logger);

                    context.Logger.LogLine($"Sent {messages.Count} messages to bus");
                    return($"Num queued messages: {messages.Count}");
                }
                else
                {
                    return("No S3 messages to queue up");
                }
            }
            catch (Exception e)
            {
                context.Logger.LogLine("Problem queing up bus messages!");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
Esempio n. 24
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task GTCToPlinkS3LambdaFunctionHandler(S3Event evnt, ILambdaContext context)
        {
            JObject preference = new Preference().preference;

            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return;
            }

            try
            {
                var result = GTCToPlinkS3.ConvertGTCToPlinkS3(bucketNameGTC: s3Event.Bucket.Name,
                                                              bucketNameBPM: preference["S3"]["BPM"]["Name"].ToString(),
                                                              bucketNamePlink: preference["S3"]["Plink"]["Name"].ToString(),
                                                              bucketRegionGTC: preference["S3"]["GTC"]["Name"].ToString(),
                                                              bucketRegionBPM: preference["S3"]["BPM"]["Region"].ToString(),
                                                              bucketRegionPlink: preference["S3"]["Plink"]["Region"].ToString(),
                                                              keyNameGTCs: new List <string> {
                    s3Event.Object.Key
                },
                                                              keyNamePlinkBasedir: preference["PlinkBase"].ToString(),
                                                              tableRegion: preference["Dynamo"]["Progress"]["Region"].ToString(),
                                                              tableName: preference["Dynamo"]["Progress"]["Name"].ToString(),
                                                              credential: @"embeded",
                                                              s3client: (AmazonS3Client)this.S3Client);
            }
            catch (Exception e)
            {
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
        public async Task <string> ConvertToJson(S3Event s3event, ILambdaContext context)
        {
            var logger   = context.Logger;
            var s3Record = s3event.Records[0].S3;

            logger.LogLine(String.Format("bucket {0}, key {1}", s3Record.Bucket.Name, s3Record.Object.Key));

            var request = new GetObjectRequest()
            {
                BucketName = s3Record.Bucket.Name,
                Key        = s3Record.Object.Key,
                ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.None
            };

            var response = await s3client.GetObjectAsync(request);

            var ddexAsJson = ParseResponse(response, logger);

            logger.LogLine(ddexAsJson);

            var putResponse = await s3client.PutObjectAsync(new PutObjectRequest( )
            {
                BucketName  = "ddex-samples-as-json",
                Key         = s3Record.Object.Key + ".json",
                ContentBody = ddexAsJson
            });

            return(putResponse.HttpStatusCode.ToString());
        }
Esempio n. 26
0
        public async Task <string> FunctionHandler(S3Event evt, ILambdaContext context)
        {
            var s3Event = evt.Records?[0].S3;
            var region  = evt.Records?[0].AwsRegion;

            if (s3Event == null)
            {
                return(null);
            }

            var imageUrl = $"https://s3.{region}.amazonaws.com/{s3Event.Bucket.Name}/{s3Event.Object.Key}";

            try
            {
                return(Optimizer.Optimize(imageUrl, CreateOutputUrl(s3Event.Object.Key)));
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}." +
                                       "Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
        private static S3Event CreateS3Event()
        {
            var s3Event = new S3Event
            {
                Records = new List <S3EventNotification.S3EventNotificationRecord>
                {
                    new S3EventNotification.S3EventNotificationRecord
                    {
                        S3 = new S3EventNotification.S3Entity
                        {
                            Bucket = new S3EventNotification.S3BucketEntity
                            {
                                Name = "TestBucketName"
                            },
                            Object = new S3EventNotification.S3ObjectEntity
                            {
                                Key = "TestKey"
                            }
                        }
                    }
                }
            };

            return(s3Event);
        }
Esempio n. 28
0
        public async Task TestS3EventLambdaFunction()
        {
            var s3Event = new S3Event
            {
                Records = new List <S3EventNotification.S3EventNotificationRecord>
                {
                    new S3EventNotification.S3EventNotificationRecord
                    {
                        S3 = new S3EventNotification.S3Entity
                        {
                            Bucket = new S3EventNotification.S3BucketEntity {
                                Name = "videos-2-process"
                            },
                            Object = new S3EventNotification.S3ObjectEntity {
                                Key = "unsafe-video.mp4"
                            }
                        }
                    }
                }
            };

            Function function = new Function();

            // Invoke the lambda function and confirm the content type was returned.
            await function.FunctionHandler(s3Event, null).ConfigureAwait(false);
        }
Esempio n. 29
0
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <ResponeModel> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var s3Event = evnt.Records?[0].S3;

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var response = await this.S3Client.GetObjectMetadataAsync(s3Event.Bucket.Name, s3Event.Object.Key);

                var result = new ResponeModel
                {
                    BucketName  = s3Event.Bucket.Name,
                    Key         = s3Event.Object.Key,
                    ContentType = response.Headers.ContentType,
                    Size        = s3Event.Object.Size,
                    EventSource = evnt.Records?[0].EventSource
                };
                context.Logger.LogLine($"EventSource {evnt.Records?[0].EventSource} from bucket {s3Event.Bucket.Name} Key {s3Event.Object.Key} ContentType {response.Headers.ContentType}.");
                return(result);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }
        /// <summary>
        /// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
        /// to respond to S3 notifications.
        /// </summary>
        /// <param name="evnt"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
        {
            var    s3Event = evnt.Records?[0].S3;
            string thumnailResultBucket = "thumbnail-result-s3-bucket";

            if (s3Event == null)
            {
                return(null);
            }

            try
            {
                var thumbnailStream = await GenerateThumbnail(s3Event.Bucket.Name, s3Event.Object.Key, context);

                var thumbnailKey = await UploadThumbnail(thumnailResultBucket, s3Event.Object.Key, thumbnailStream);

                string res = $"Thumbnail saved to s3://{thumnailResultBucket}/{thumbnailKey}";
                context.Logger.LogLine(res);
                return(res);
            }
            catch (Exception e)
            {
                context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
                context.Logger.LogLine(e.Message);
                context.Logger.LogLine(e.StackTrace);
                throw;
            }
        }