Initial commit

Author: matsimitsu

.gitignore

@@ -0,0 +1,10 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "lambda-image-resize-rust"
+version = "0.1.0"
+authors = ["Robert Beekman <[email protected]>"]
+
+[dependencies]
+lambda_runtime = "0.1"
+serde = "^1"
+serde_json = "^1"
+serde_derive = "*"
+log = "^0.4"
+simple_logger = "^1"
+aws_lambda_events = "^0.2.0"
+rust-s3 = "0.10.0"
+image= "*"
+rayon = "1.0"
+
+[[bin]]
+name = "bootstrap"
+path = "src/main.rs"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Robert Beekman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,9 @@
+build:
+	docker run --rm \
+		-v ${PWD}:/code \
+		-v ${HOME}/.cargo/registry:/root/.cargo/registry \
+		-v ${HOME}/.cargo/git:/root/.cargo/git \
+		softprops/lambda-rust
+
+rust_version:
+	rustup override add 1.32.0

README.md

@@ -0,0 +1,22 @@
+# Lambda Image Resize
+
+A simple image resize lambda function, written in Rust.
+
+This binary responds to Amazon S3 events and triggers a resize on the uploaded image with the sizes specified. Right now you can only resize on the width of an image.
+
+## Configure
+
+This binary relies on two env vars:
+
+* `SIZES`, an array if sizes (`export SIZES=200,300,400`)
+* `REPLACEMENTS`, an array of replacements for the path (`export REPLACEMENTS="original:resized"`)
+
+## Compile
+
+Use [Lambda-Rust docker image](https://hub.docker.com/r/softprops/lambda-rust/) to compile this binary. With Docker running run the following command to build a release.
+
+```
+make build
+```
+
+You can find the (zipped) bootstrap ready for upload to AWS Lambda in `target/lambda/release/bootstrap.zip`

src/config.rs

@@ -0,0 +1,39 @@
+use std::env;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Config {
+    pub sizes: Vec<f32>,
+    pub replacements: Vec<(String, String)>,
+}
+
+impl Config {
+    pub fn new() -> Config {
+        Config {
+            sizes: Config::parse_sizes(),
+            replacements: Config::parse_replacements(),
+        }
+    }
+
+    pub fn parse_sizes() -> Vec<f32> {
+        let mut sizes = Vec::new();
+        if let Ok(sizes_string) = env::var("SIZES") {
+            for size_string in sizes_string.split(',').into_iter() {
+                sizes.push(size_string.parse().unwrap());
+            }
+        };
+
+        sizes
+    }
+
+    pub fn parse_replacements() -> Vec<(String, String)> {
+        let mut replacements = Vec::new();
+        if let Ok(replacements_string) = env::var("REPLACEMENTS") {
+            for replacement in replacements_string.split(',').into_iter() {
+                let key_val: Vec<&str> = replacement.splitn(2, ":").collect();
+                replacements.push((key_val[0].to_string(), key_val[1].to_string()));
+            }
+        };
+
+        replacements
+    }
+}

src/main.rs

@@ -0,0 +1,123 @@
+extern crate aws_lambda_events;
+extern crate image;
+#[macro_use]
+extern crate lambda_runtime as lambda;
+#[macro_use]
+extern crate log;
+extern crate rayon;
+extern crate s3;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde_json;
+extern crate simple_logger;
+
+use image::{GenericImageView, ImageError, JPEG};
+use rayon::prelude::*;
+use s3::bucket::Bucket;
+use s3::credentials::Credentials;
+use s3::region::Region;
+
+mod config;
+
+use aws_lambda_events::event::s3::{S3Event, S3EventRecord};
+use config::Config;
+use lambda::error::HandlerError;
+use serde_json::Value;
+use std::error::Error;
+
+fn main() -> Result<(), Box<Error>> {
+    simple_logger::init_with_level(log::Level::Info)?;
+
+    lambda!(handle_event);
+
+    Ok(())
+}
+
+fn handle_event(event: Value, ctx: lambda::Context) -> Result<(), HandlerError> {
+    let config = Config::new();
+
+    let s3_event: S3Event =
+        serde_json::from_value(event).map_err(|e| ctx.new_error(e.to_string().as_str()))?;
+
+    for record in s3_event.records {
+        handle_record(&config, record);
+    }
+    Ok(())
+}
+
+fn handle_record(config: &Config, record: S3EventRecord) {
+    let credentials = Credentials::default();
+    let region: Region = record
+        .aws_region
+        .expect("Could not get region from record")
+        .parse()
+        .expect("Could not parse region from record");
+    let bucket = Bucket::new(
+        &record
+            .s3
+            .bucket
+            .name
+            .expect("Could not get bucket name from record"),
+        region,
+        credentials,
+    );
+    let source = record
+        .s3
+        .object
+        .key
+        .expect("Could not get key from object record");
+    info!("Fetching: {}, config: {:?}", &source, &config);
+
+    /* Make sure we don't process files twice */
+    for size in &config.sizes {
+        let to_match = format!("-{}.jpg", size);
+        if source.ends_with(&to_match) {
+            warn!(
+                "Source: '{}' ends with: '{}'. Skipping.",
+                &source,
+                &to_match
+            );
+            return;
+        }
+    }
+
+    let (data, _) = bucket
+        .get(&source)
+        .expect(&format!("Could not get object: {}", &source));
+
+    let img = image::load_from_memory(&data)
+        .ok()
+        .expect("Opening image failed");
+
+    let _: Vec<_> = config
+        .sizes
+        .par_iter()
+        .map(|size| {
+            let buffer = resize_image(&img, &size).expect("Could not resize image");
+
+            let mut target = source.clone();
+            for (rep_key, rep_val) in &config.replacements {
+                target = target.replace(rep_key, rep_val);
+            }
+            target = target.replace(".jpg", &format!("-{}.jpg", size));
+            let (_, code) = bucket
+                .put(&target, &buffer, "image/jpeg")
+                .expect(&format!("Could not upload object to :{}", &target));
+            info!("Uploaded: {} with: {}", &target, &code);
+        })
+        .collect();
+}
+
+fn resize_image(img: &image::DynamicImage, new_w: &f32) -> Result<Vec<u8>, ImageError> {
+    let mut result: Vec<u8> = Vec::new();
+
+    let old_w = img.width() as f32;
+    let old_h = img.height() as f32;
+    let ratio = new_w / old_w;
+    let new_h = (old_h * ratio).floor();
+
+    let scaled = img.resize(*new_w as u32, new_h as u32, image::FilterType::Lanczos3);
+    scaled.write_to(&mut result, JPEG)?;
+
+    Ok(result)
+}