Examples basic s3 object lambda thumbnail (#664)

* fix example basic-s3-thumbnail test

* basic-s3-object-lambda-thumbnail example (#625)

Forwards a thumbnail to the user instead of the requested file

Author: peterborkuti

examples/basic-s3-object-lambda-thumbnail/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "basic-s3-object-lambda-thumbnail"
+version = "0.1.0"
+edition = "2021"
+
+# Starting in Rust 1.62 you can use `cargo add` to add dependencies 
+# to your project.
+#
+# If you're using an older Rust version,
+# download cargo-edit(https://github.com/killercup/cargo-edit#installation) 
+# to install the `add` subcommand.
+#
+# Running `cargo add DEPENDENCY_NAME` will
+# add the latest version of a dependency to the list,
+# and it will keep the alphabetic ordering for you.
+
+[dependencies]
+aws_lambda_events = "0.8.3"
+lambda_runtime = { path = "../../lambda-runtime" }
+serde = "1"
+tokio = { version = "1", features = ["macros"] }
+tracing = { version = "0.1" }
+tracing-subscriber = { version = "0.3", default-features = false, features = ["ansi", "fmt"] }
+aws-config = "0.55.3"
+aws-sdk-s3 = "0.28.0"
+thumbnailer = "0.4.0"
+mime = "0.3.16"
+async-trait = "0.1.66"
+ureq = "2.6.2"
+aws-smithy-http = "0.55.3"
+
+[dev-dependencies]
+mockall = "0.11.3"
+tokio-test = "0.4.2"

examples/basic-s3-object-lambda-thumbnail/README.md

@@ -0,0 +1,40 @@
+# AWS S3 Object Lambda Function
+
+It uses a GetObject event and it returns with a thumbnail instead of the real
+object from the S3 bucket.
+The thumbnail was tested only witn PNG files.
+
+## Build & Deploy
+
+1. Install [cargo-lambda](https://github.com/cargo-lambda/cargo-lambda#installation)
+2. Build the function with `cargo lambda build --release --arm64 --output-format zip`
+3. Upload the bootstrap.zip file from the directory:`target/lambda/basic-s3-object-lambda-thumbnail/`
+
+## Setup on AWS S3
+
+1. You need a bucket and upload a PNG file to that bucket
+2. Set Access Point for that bucket
+3. Set Object Lambda Access Point for the access point and use the uploaded lambda function as a transformer
+
+## Set Up on AWS Lambda
+
+0. Click on Code tab
+1. Runtime settings - runtime: Custom runtime on Amazon Linux 2
+2. Runtime settings - Architecture: arm64
+
+## Set Up on AWS IAM
+
+1. Click on Roles
+2. Search the lambda function name
+3. Add the permission: AmazonS3ObjectLambdaExecutionRolePolicy
+
+## How to check this lambda
+
+1. Go to S3
+2. Click on Object Lambda Access Point
+3. Click on your object lambda access point name
+4. click on one uploaded PNG file
+5. Click on the activated Open button
+
+### Expected:
+A new browser tab opens with a 128x128 thumbnail

examples/basic-s3-object-lambda-thumbnail/src/main.rs

@@ -0,0 +1,178 @@
+use std::{error, io::Cursor};
+
+use aws_lambda_events::s3::object_lambda::{GetObjectContext, S3ObjectLambdaEvent};
+use aws_sdk_s3::Client as S3Client;
+use lambda_runtime::{run, service_fn, Error, LambdaEvent};
+use s3::{GetFile, SendFile};
+use thumbnailer::{create_thumbnails, ThumbnailSize};
+
+mod s3;
+
+/**
+This s3 object lambda handler
+    * downloads the asked file
+    * creates a PNG thumbnail from it
+    * forwards it to the browser
+*/
+pub(crate) async fn function_handler<T: SendFile + GetFile>(
+    event: LambdaEvent<S3ObjectLambdaEvent>,
+    size: u32,
+    client: &T,
+) -> Result<String, Box<dyn error::Error>> {
+    tracing::info!("handler starts");
+
+    let context: GetObjectContext = event.payload.get_object_context.unwrap();
+
+    let route = context.output_route;
+    let token = context.output_token;
+    let s3_url = context.input_s3_url;
+
+    tracing::info!("Route: {}, s3_url: {}", route, s3_url);
+
+    let image = client.get_file(s3_url)?;
+    tracing::info!("Image loaded. Length: {}", image.len());
+
+    let thumbnail = get_thumbnail(image, size);
+    tracing::info!("thumbnail created. Length: {}", thumbnail.len());
+
+    // It sends the thumbnail back to the user
+
+    client.send_file(route, token, thumbnail).await
+
+    /*
+    match client.send_file(route, token, thumbnail).await {
+        Ok(msg) => tracing::info!(msg),
+        Err(msg) => tracing::info!(msg)
+    };
+
+    tracing::info!("handler ends");
+
+    Ok(())
+    */
+}
+
+fn get_thumbnail(vec: Vec<u8>, size: u32) -> Vec<u8> {
+    let reader = Cursor::new(vec);
+    let mut thumbnails = create_thumbnails(reader, mime::IMAGE_PNG, [ThumbnailSize::Custom((size, size))]).unwrap();
+
+    let thumbnail = thumbnails.pop().unwrap();
+    let mut buf = Cursor::new(Vec::new());
+    thumbnail.write_png(&mut buf).unwrap();
+
+    buf.into_inner()
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    // required to enable CloudWatch error logging by the runtime
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::TRACE)
+        // disable printing the name of the module in every log line.
+        .with_target(false)
+        // this needs to be set to false, otherwise ANSI color codes will
+        // show up in a confusing manner in CloudWatch logs.
+        .with_ansi(false)
+        // disabling time is handy because CloudWatch will add the ingestion time.
+        .without_time()
+        .init();
+
+    let shared_config = aws_config::load_from_env().await;
+    let client = S3Client::new(&shared_config);
+    let client_ref = &client;
+
+    let func = service_fn(move |event| async move { function_handler(event, 128, client_ref).await });
+
+    let _ = run(func).await;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs::File;
+    use std::io::BufReader;
+    use std::io::Read;
+
+    use super::*;
+    use async_trait::async_trait;
+    use aws_lambda_events::s3::object_lambda::Configuration;
+    use aws_lambda_events::s3::object_lambda::HeadObjectContext;
+    use aws_lambda_events::s3::object_lambda::ListObjectsContext;
+    use aws_lambda_events::s3::object_lambda::ListObjectsV2Context;
+    use aws_lambda_events::s3::object_lambda::UserIdentity;
+    use aws_lambda_events::s3::object_lambda::UserRequest;
+    use aws_lambda_events::serde_json::json;
+    use lambda_runtime::{Context, LambdaEvent};
+    use mockall::mock;
+    use s3::GetFile;
+    use s3::SendFile;
+
+    #[tokio::test]
+    async fn response_is_good() {
+        mock! {
+            FakeS3Client {}
+
+            #[async_trait]
+            impl GetFile for FakeS3Client {
+                pub fn get_file(&self, url: String) -> Result<Vec<u8>, Box<dyn error::Error>>;
+            }
+            #[async_trait]
+            impl SendFile for FakeS3Client {
+                pub async fn send_file(&self, route: String, token: String, vec: Vec<u8>) -> Result<String, Box<dyn error::Error>>;
+            }
+        }
+
+        let mut mock = MockFakeS3Client::new();
+
+        mock.expect_get_file()
+            .withf(|u: &String| u.eq("S3_URL"))
+            .returning(|_1| Ok(get_file("testdata/image.png")));
+
+        mock.expect_send_file()
+            .withf(|r: &String, t: &String, by| {
+                let thumbnail = get_file("testdata/thumbnail.png");
+                return r.eq("O_ROUTE") && t.eq("O_TOKEN") && by == &thumbnail;
+            })
+            .returning(|_1, _2, _3| Ok("File sent.".to_string()));
+
+        let payload = get_s3_event();
+        let context = Context::default();
+        let event = LambdaEvent { payload, context };
+
+        let result = function_handler(event, 10, &mock).await.unwrap();
+
+        assert_eq!(("File sent."), result);
+    }
+
+    fn get_file(name: &str) -> Vec<u8> {
+        let f = File::open(name);
+        let mut reader = BufReader::new(f.unwrap());
+        let mut buffer = Vec::new();
+
+        reader.read_to_end(&mut buffer).unwrap();
+
+        return buffer;
+    }
+
+    fn get_s3_event() -> S3ObjectLambdaEvent {
+        return S3ObjectLambdaEvent {
+            x_amz_request_id: ("ID".to_string()),
+            head_object_context: (Some(HeadObjectContext::default())),
+            list_objects_context: (Some(ListObjectsContext::default())),
+            get_object_context: (Some(GetObjectContext {
+                input_s3_url: ("S3_URL".to_string()),
+                output_route: ("O_ROUTE".to_string()),
+                output_token: ("O_TOKEN".to_string()),
+            })),
+            list_objects_v2_context: (Some(ListObjectsV2Context::default())),
+            protocol_version: ("VERSION".to_string()),
+            user_identity: (UserIdentity::default()),
+            user_request: (UserRequest::default()),
+            configuration: (Configuration {
+                access_point_arn: ("APRN".to_string()),
+                supporting_access_point_arn: ("SAPRN".to_string()),
+                payload: (json!(null)),
+            }),
+        };
+    }
+}

examples/basic-s3-object-lambda-thumbnail/src/s3.rs

@@ -0,0 +1,90 @@
+use async_trait::async_trait;
+use aws_sdk_s3::{operation::write_get_object_response::WriteGetObjectResponseError, Client as S3Client};
+use aws_smithy_http::{byte_stream::ByteStream, result::SdkError};
+use std::{error, io::Read};
+
+pub trait GetFile {
+    fn get_file(&self, url: String) -> Result<Vec<u8>, Box<dyn error::Error>>;
+}
+
+#[async_trait]
+pub trait SendFile {
+    async fn send_file(&self, route: String, token: String, vec: Vec<u8>) -> Result<String, Box<dyn error::Error>>;
+}
+
+impl GetFile for S3Client {
+    fn get_file(&self, url: String) -> Result<Vec<u8>, Box<dyn error::Error>> {
+        tracing::info!("get file url {}", url);
+
+        let resp = ureq::get(&url).call()?;
+        let len: usize = resp.header("Content-Length").unwrap().parse()?;
+
+        let mut bytes: Vec<u8> = Vec::with_capacity(len);
+
+        std::io::Read::take(resp.into_reader(), 10_000_000).read_to_end(&mut bytes)?;
+
+        tracing::info!("got {} bytes", bytes.len());
+
+        Ok(bytes)
+    }
+}
+
+#[async_trait]
+impl SendFile for S3Client {
+    async fn send_file(&self, route: String, token: String, vec: Vec<u8>) -> Result<String, Box<dyn error::Error>> {
+        tracing::info!("send file route {}, token {}, length {}", route, token, vec.len());
+
+        let bytes = ByteStream::from(vec);
+
+        let write = self
+            .write_get_object_response()
+            .request_route(route)
+            .request_token(token)
+            .status_code(200)
+            .body(bytes)
+            .send()
+            .await;
+
+        if write.is_err() {
+            let sdk_error = write.err().unwrap();
+            check_error(sdk_error);
+            Err("WriteGetObjectResponse creation error".into())
+        } else {
+            Ok("File sent.".to_string())
+        }
+    }
+}
+
+fn check_error(error: SdkError<WriteGetObjectResponseError>) {
+    match error {
+        SdkError::ConstructionFailure(_err) => {
+            tracing::info!("ConstructionFailure");
+        }
+        SdkError::DispatchFailure(err) => {
+            tracing::info!("DispatchFailure");
+            if err.is_io() {
+                tracing::info!("IO error");
+            };
+            if err.is_timeout() {
+                tracing::info!("Timeout error");
+            };
+            if err.is_user() {
+                tracing::info!("User error");
+            };
+            if err.is_other().is_some() {
+                tracing::info!("Other error");
+            };
+        }
+        SdkError::ResponseError(_err) => tracing::info!("ResponseError"),
+        SdkError::TimeoutError(_err) => tracing::info!("TimeoutError"),
+        SdkError::ServiceError(err) => {
+            tracing::info!("ServiceError");
+            let wgore = err.into_err();
+            let meta = wgore.meta();
+            let code = meta.code().unwrap_or_default();
+            let msg = meta.message().unwrap_or_default();
+            tracing::info!("code: {}, message: {}, meta: {}", code, msg, meta);
+        }
+        _ => tracing::info!("other error"),
+    }
+}

examples/basic-s3-object-lambda-thumbnail/testdata/image.png

@@ -30,3 +30,4 @@ async-trait = "0.1.66"
 [dev-dependencies]
 mockall = "0.11.3"
 tokio-test = "0.4.2"
+chrono = "0.4"

examples/basic-s3-object-lambda-thumbnail/testdata/thumbnail.png

@@ -138,7 +138,7 @@ mod tests {
 
     use super::*;
     use async_trait::async_trait;
-    use aws_lambda_events::chrono::DateTime;
+    //use aws_lambda_events::chrono::DateTime;
     use aws_lambda_events::s3::S3Bucket;
     use aws_lambda_events::s3::S3Entity;
     use aws_lambda_events::s3::S3Object;
@@ -214,7 +214,7 @@ mod tests {
             configuration_id: (Some(String::default())),
             bucket: (S3Bucket {
                 name: (Some(bucket_name.to_string())),
-                owner_identity: (S3UserIdentity {
+                owner_identity: Some(S3UserIdentity {
                     principal_id: (Some(String::default())),
                 }),
                 arn: (Some(String::default())),
@@ -233,7 +233,7 @@ mod tests {
             event_version: (Some(String::default())),
             event_source: (Some(String::default())),
             aws_region: (Some(String::default())),
-            event_time: (DateTime::default()),
+            event_time: (chrono::DateTime::default()),
             event_name: (Some(event_name.to_string())),
             principal_id: (S3UserIdentity {
                 principal_id: (Some("X".to_string())),