Adapt lambda-http to new lambda runtime api (awslabs#217)

Author: softprops

.github/workflows/build.yml

@@ -12,7 +12,6 @@ jobs:
           - ubuntu-latest
           - macOS-latest
         rust:
-          - 1.40.0
           - stable
           - beta
           - nightly

Cargo.lock

@@ -1,5 +1,6 @@
 [workspace]
 members = [
     "lambda",
-    "lambda-attributes"
+    "lambda-attributes",
+    "lambda-http"
 ]

Cargo.toml

@@ -2,12 +2,20 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use quote::quote_spanned;
-use syn::{spanned::Spanned, FnArg, ItemFn};
+use syn::{spanned::Spanned, AttributeArgs, FnArg, ItemFn, Meta, NestedMeta};
+
+/// Return true if attribute macro args declares http flavor in the form `#[lambda(http)]`
+fn is_http(args: &AttributeArgs) -> bool {
+    args.iter().any(|arg| match arg {
+        NestedMeta::Meta(Meta::Path(path)) => path.is_ident("http"),
+        _ => false,
+    })
+}
 
 #[proc_macro_attribute]
-pub fn lambda(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub fn lambda(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(item as ItemFn);
-
+    let args = syn::parse_macro_input!(attr as AttributeArgs);
     let ret = &input.sig.output;
     let name = &input.sig.ident;
     let body = &input.block;
@@ -17,7 +25,7 @@ pub fn lambda(_attr: TokenStream, item: TokenStream) -> TokenStream {
 
     if name != "main" {
         let tokens = quote_spanned! { name.span() =>
-            compile_error!("only the main function can be tagged with #[lambda::main]");
+            compile_error!("only the main function can be tagged with #[lambda]");
         };
         return TokenStream::from(tokens);
     }
@@ -43,16 +51,32 @@ pub fn lambda(_attr: TokenStream, item: TokenStream) -> TokenStream {
             let arg_name = &event.pat;
             let arg_type = &event.ty;
 
-            quote_spanned! { input.span() =>
-                use lambda::LambdaCtx;
+            if is_http(&args) {
+                quote_spanned! { input.span() =>
+                    use lambda_http::lambda::LambdaCtx;
+
+                    #(#attrs)*
+                    #asyncness fn main() {
+                        async fn actual(#arg_name: #arg_type) #ret {
+                            #body
+                        }
+                        let f = lambda_http::handler(actual);
+                        lambda_http::lambda::run(f).await.unwrap();
+                    }
+                }
+            } else {
+                quote_spanned! { input.span() =>
+
+                    use lambda::LambdaCtx;
 
-                #(#attrs)*
-                #asyncness fn main() {
-                    async fn actual(#arg_name: #arg_type) #ret {
-                        #body
+                    #(#attrs)*
+                    #asyncness fn main() {
+                        async fn actual(#arg_name: #arg_type) #ret {
+                            #body
+                        }
+                        let f = lambda::handler_fn(actual);
+                        lambda::run(f).await.unwrap();
                     }
-                    let f = lambda::handler_fn(actual);
-                    lambda::run(f).await.unwrap();
                 }
             }
         }

lambda-attributes/src/lib.rs

@@ -1,9 +1,9 @@
 [package]
 name = "lambda_http"
-version = "0.1.1"
+version = "0.2.0-beta.1"
 authors = ["Doug Tangren"]
 edition = "2018"
-description = "Rust API Gateway proxy event interfaces for AWS Lambda"
+description = "Application Load Balancer and API Gateway event types for AWS Lambda"
 keywords = ["AWS", "Lambda", "APIGateway", "ALB", "API"]
 license = "Apache-2.0"
 homepage = "https://github.com/awslabs/aws-lambda-rust-runtime"
@@ -16,18 +16,16 @@ travis-ci = { repository = "awslabs/aws-lambda-rust-runtime" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-http = "0.1"
+base64 = "0.12"
+http = "0.2"
+lambda = { path = "../lambda", version = "0.1" }
+lambda-attributes = { path = "../lambda-attributes", version = "0.1" }
 serde = "^1"
-serde_json = "^1"
 serde_derive = "^1"
-lambda = { path = "../lambda" }
-tokio = "^0.1"
-base64 = "0.10"
-failure = "0.1"
-failure_derive = "0.1"
-serde_urlencoded = "0.5"
+serde_json = "^1"
+serde_urlencoded = "0.6"
 
 [dev-dependencies]
 log = "^0.4"
 maplit = "1.0"
-simple_logger = "^1"
+tokio = { version = "0.2", features = ["macros"] }

lambda-http/Cargo.toml

@@ -1,26 +1,19 @@
-use std::error::Error;
+use lambda_http::{handler, lambda, IntoResponse, Request, RequestExt, Response};
 
-use lambda_http::{lambda, IntoResponse, Request, RequestExt, Response};
-use lambda_runtime::{error::HandlerError, Context};
-use log::{self, error};
-use simple_logger;
-
-fn main() -> Result<(), Box<dyn Error>> {
-    simple_logger::init_with_level(log::Level::Debug)?;
-    lambda!(my_handler);
+type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    lambda::run(handler(func)).await?;
     Ok(())
 }
 
-fn my_handler(e: Request, c: Context) -> Result<impl IntoResponse, HandlerError> {
-    Ok(match e.query_string_parameters().get("first_name") {
+async fn func(event: Request) -> Result<impl IntoResponse, Error> {
+    Ok(match event.query_string_parameters().get("first_name") {
         Some(first_name) => format!("Hello, {}!", first_name).into_response(),
-        _ => {
-            error!("Empty first name in request {}", c.aws_request_id);
-            Response::builder()
-                .status(400)
-                .body("Empty first name".into())
-                .expect("failed to render response")
-        }
+        _ => Response::builder()
+            .status(400)
+            .body("Empty first name".into())
+            .expect("failed to render response"),
     })
 }

lambda-http/examples/basic.rs

@@ -0,0 +1,9 @@
+use lambda_http::{lambda, IntoResponse, Request};
+
+type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+#[lambda(http)]
+#[tokio::main]
+async fn main(_: Request) -> Result<impl IntoResponse, Error> {
+    Ok("👋 world")
+}

lambda-http/examples/hello.rs

@@ -68,6 +68,22 @@ pub enum Body {
     Binary(Vec<u8>),
 }
 
+impl Body {
+    /// Decodes body, if needed.
+    ///
+    /// # Panics
+    ///
+    /// Panics when aws communicates to handler that request is base64 encoded but
+    /// it can not be base64 decoded
+    pub(crate) fn from_maybe_encoded(is_base64_encoded: bool, body: Cow<'_, str>) -> Body {
+        if is_base64_encoded {
+            Body::from(::base64::decode(body.as_ref()).expect("failed to decode aws base64 encoded body"))
+        } else {
+            Body::from(body.as_ref())
+        }
+    }
+}
+
 impl Default for Body {
     fn default() -> Self {
         Body::Empty