feat(lambda-http): implement tower::Service (part 3)

nmoutschen · nmoutschen · commit 84d41c9ba069 · 2022-01-20T19:07:50.000+01:00
diff --git a/lambda-http/examples/hello-http.rs b/lambda-http/examples/hello-http.rs
@@ -1,16 +1,12 @@
-use lambda_http::{
-    handler,
-    lambda_runtime::{self, Context, Error},
-    IntoResponse, Request, RequestExt, Response,
-};
+use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    lambda_runtime::run(handler(func)).await?;
+    lambda_http::run(service_fn(func)).await?;
     Ok(())
 }
 
-async fn func(event: Request, _: Context) -> Result<impl IntoResponse, Error> {
+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(),
         _ => Response::builder()
diff --git a/lambda-http/examples/shared-resources-example.rs b/lambda-http/examples/shared-resources-example.rs
@@ -1,8 +1,4 @@
-use lambda_http::{
-    handler,
-    lambda_runtime::{self, Context, Error},
-    IntoResponse, Request, RequestExt, Response,
-};
+use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};
 
 struct SharedClient {
     name: &'static str,
@@ -23,9 +19,11 @@ async fn main() -> Result<(), Error> {
     let shared_client_ref = &shared_client;
 
     // Define a closure here that makes use of the shared client.
-    let handler_func_closure = move |event: Request, ctx: Context| async move {
+    let handler_func_closure = move |event: Request| async move {
         Ok(match event.query_string_parameters().get("first_name") {
-            Some(first_name) => shared_client_ref.response(ctx.request_id, first_name).into_response(),
+            Some(first_name) => shared_client_ref
+                .response(event.lambda_context().request_id, first_name)
+                .into_response(),
             _ => Response::builder()
                 .status(400)
                 .body("Empty first name".into())
@@ -34,6 +32,6 @@ async fn main() -> Result<(), Error> {
     };
 
     // Pass the closure to the runtime here.
-    lambda_runtime::run(handler(handler_func_closure)).await?;
+    lambda_http::run(service_fn(handler_func_closure)).await?;
     Ok(())
 }
diff --git a/lambda-http/src/ext.rs b/lambda-http/src/ext.rs
@@ -1,6 +1,7 @@
 //! Extension methods for `http::Request` types
 
 use crate::{request::RequestContext, strmap::StrMap, Body};
+use lambda_runtime::Context;
 use serde::{de::value::Error as SerdeError, Deserialize};
 use std::{error::Error, fmt};
 
@@ -167,6 +168,12 @@ pub trait RequestExt {
     fn payload<D>(&self) -> Result<Option<D>, PayloadError>
     where
         for<'de> D: Deserialize<'de>;
+
+    /// Return the Lambda function context associated with the request
+    fn lambda_context(&self) -> Context;
+
+    /// Configures instance with lambda context
+    fn with_lambda_context(self, context: Context) -> Self;
 }
 
 impl RequestExt for http::Request<Body> {
@@ -226,6 +233,19 @@ impl RequestExt for http::Request<Body> {
             .expect("Request did not contain a request context")
     }
 
+    fn lambda_context(&self) -> Context {
+        self.extensions()
+            .get::<Context>()
+            .cloned()
+            .expect("Request did not contain a lambda context")
+    }
+
+    fn with_lambda_context(self, context: Context) -> Self {
+        let mut s = self;
+        s.extensions_mut().insert(context);
+        s
+    }
+
     fn payload<D>(&self) -> Result<Option<D>, PayloadError>
     where
         for<'de> D: Deserialize<'de>,
diff --git a/lambda-http/src/lib.rs b/lambda-http/src/lib.rs
@@ -17,13 +17,13 @@
 //! your function's execution path.
 //!
 //! ```rust,no_run
-//! use lambda_http::{handler, lambda_runtime::{self, Error}};
+//! use lambda_http::{service_fn, Error};
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Error> {
 //!     // initialize dependencies once here for the lifetime of your
 //!     // lambda task
-//!     lambda_runtime::run(handler(|request, context| async { Ok("👋 world!") })).await?;
+//!     lambda_http::run(service_fn(|request| async { Ok("👋 world!") })).await?;
 //!     Ok(())
 //! }
 //! ```
@@ -34,17 +34,16 @@
 //! with the [`RequestExt`](trait.RequestExt.html) trait.
 //!
 //! ```rust,no_run
-//! use lambda_http::{handler, lambda_runtime::{self, Context, Error}, IntoResponse, Request, RequestExt};
+//! use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt};
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Error> {
-//!     lambda_runtime::run(handler(hello)).await?;
+//!     lambda_http::run(service_fn(hello)).await?;
 //!     Ok(())
 //! }
 //!
 //! async fn hello(
-//!     request: Request,
-//!     _: Context
+//!     request: Request
 //! ) -> Result<impl IntoResponse, Error> {
 //!     Ok(format!(
 //!         "hello {}",
@@ -62,11 +61,8 @@
 extern crate maplit;
 
 pub use http::{self, Response};
-pub use lambda_runtime::{self, Context};
-use lambda_runtime::{
-    tower::util::{service_fn, ServiceFn},
-    Error, LambdaEvent, Service,
-};
+pub use lambda_runtime::{self, tower::util::service_fn, Context, Error};
+use lambda_runtime::{LambdaEvent, Service};
 
 mod body;
 pub mod ext;
@@ -88,27 +84,10 @@ use std::{
 /// Type alias for `http::Request`s with a fixed [`Body`](enum.Body.html) type
 pub type Request = http::Request<Body>;
 
-/// Wraps a function that takes 2 arguments into one that only takes a [`LambdaEvent`]
-fn handler_wrapper<A, Fut>(f: impl Fn(A, Context) -> Fut) -> impl Fn(LambdaEvent<A>) -> Fut {
-    move |req| f(req.event, req.context)
-}
-
-/// Adapts a [`Service`] into another [`Service`].
-pub fn handler<'a, R, Fut>(
-    f: impl Fn(Request, Context) -> Fut,
-) -> Adapter<'a, R, ServiceFn<impl Fn(LambdaEvent<Request>) -> Fut>>
-where
-    R: IntoResponse,
-    Fut: Future<Output = Result<R, Error>>,
-{
-    Adapter {
-        service: service_fn(handler_wrapper(f)),
-        _phantom_data: PhantomData,
-    }
-}
-
-#[doc(hidden)]
-pub struct TransformResponse<'a, R, E> {
+/// Future that will convert an [`IntoResponse`] into an actual [`LambdaResponse`]
+///
+/// This is used by the `Adapter` wrapper and is completely internal to the `lambda_http::run` function.
+struct TransformResponse<'a, R, E> {
     request_origin: RequestOrigin,
     fut: Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a>>,
 }
@@ -129,15 +108,31 @@ where
     }
 }
 
-#[doc(hidden)]
-pub struct Adapter<'a, R, S> {
+/// Wraps a `Service<Request>` in a `Service<LambdaEvent<Request>>`
+///
+/// This is completely internal to the `lambda_http::run` function.
+struct Adapter<'a, R, S> {
     service: S,
     _phantom_data: PhantomData<&'a R>,
 }
 
+impl<'a, R, S> From<S> for Adapter<'a, R, S>
+where
+    S: Service<Request, Response = R, Error = Error> + Send,
+    S::Future: Send + 'a,
+    R: IntoResponse,
+{
+    fn from(service: S) -> Self {
+        Adapter {
+            service,
+            _phantom_data: PhantomData,
+        }
+    }
+}
+
 impl<'a, R, S> Service<LambdaEvent<LambdaRequest<'a>>> for Adapter<'a, R, S>
 where
-    S: Service<LambdaEvent<Request>, Response = R, Error = Error> + Send,
+    S: Service<Request, Response = R, Error = Error> + Send,
     S::Future: Send + 'a,
     R: IntoResponse,
 {
@@ -151,7 +146,22 @@ where
 
     fn call(&mut self, req: LambdaEvent<LambdaRequest<'a>>) -> Self::Future {
         let request_origin = req.event.request_origin();
-        let fut = Box::pin(self.service.call(LambdaEvent::new(req.event.into(), req.context)));
+        let event: Request = req.event.into();
+        let fut = Box::pin(self.service.call(event.with_lambda_context(req.context)));
         TransformResponse { request_origin, fut }
     }
 }
+
+/// Starts the Lambda Rust runtime and begins polling for events on the [Lambda
+/// Runtime APIs](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html).
+///
+/// This takes care of transforming the LambdaEvent into a [`Request`] and then
+/// converting the result into a [`LambdaResponse`].
+pub async fn run<'a, S, R>(handler: S) -> Result<(), Error>
+where
+    S: Service<Request, Response = R, Error = Error> + Send,
+    S::Future: Send + 'a,
+    R: IntoResponse,
+{
+    lambda_runtime::run(Adapter::from(handler)).await
+}
diff --git a/lambda-integration-tests/src/bin/http-fn.rs b/lambda-integration-tests/src/bin/http-fn.rs
@@ -1,10 +1,8 @@
-use lambda_http::{
-    lambda_runtime::{self, Context, Error},
-    IntoResponse, Request, Response,
-};
+use lambda_http::{service_fn, Error, IntoResponse, Request, RequestExt, Response};
 use tracing::info;
 
-async fn handler(event: Request, _context: Context) -> Result<impl IntoResponse, Error> {
+async fn handler(event: Request) -> Result<impl IntoResponse, Error> {
+    let _context = event.lambda_context();
     info!("[http-fn] Received event {} {}", event.method(), event.uri().path());
 
     Ok(Response::builder().status(200).body("Hello, world!").unwrap())
@@ -23,6 +21,6 @@ async fn main() -> Result<(), Error> {
         .without_time()
         .init();
 
-    let handler = lambda_http::handler(handler);
-    lambda_runtime::run(handler).await
+    let handler = service_fn(handler);
+    lambda_http::run(handler).await
 }
