Allow Adapter to be .boxed() (#540)

dcormier · web-flow · commit 1e165027c3d4 · 2022-10-11T10:45:59.000-07:00
Allowing `Adapter` to be [`.boxed()`](https://docs.rs/tower/0.4.13/tower/trait.ServiceExt.html#method.boxed) enables easier composition of `tower::Service`s that may include additional middleware prior to `Adapter` converting the `LambdaEvent` to a `Request`.
diff --git a/lambda-http/src/lib.rs b/lambda-http/src/lib.rs
@@ -140,7 +140,7 @@ pub struct Adapter<'a, R, S> {
 impl<'a, R, S, E> From<S> for Adapter<'a, R, S>
 where
     S: Service<Request, Response = R, Error = E>,
-    S::Future: 'a,
+    S::Future: Send + 'a,
     R: IntoResponse,
 {
     fn from(service: S) -> Self {
@@ -154,7 +154,7 @@ where
 impl<'a, R, S, E> Service<LambdaEvent<LambdaRequest>> for Adapter<'a, R, S>
 where
     S: Service<Request, Response = R, Error = E>,
-    S::Future: 'a,
+    S::Future: Send + 'a,
     R: IntoResponse,
 {
     type Response = LambdaResponse;
@@ -182,9 +182,65 @@ where
 pub async fn run<'a, R, S, E>(handler: S) -> Result<(), Error>
 where
     S: Service<Request, Response = R, Error = E>,
-    S::Future: 'a,
+    S::Future: Send + 'a,
     R: IntoResponse,
     E: std::fmt::Debug + std::fmt::Display,
 {
     lambda_runtime::run(Adapter::from(handler)).await
 }
+
+#[cfg(test)]
+mod test_adapter {
+    use std::task::{Context, Poll};
+
+    use crate::{
+        http::{Response, StatusCode},
+        lambda_runtime::LambdaEvent,
+        request::LambdaRequest,
+        response::LambdaResponse,
+        tower::{util::BoxService, Service, ServiceBuilder, ServiceExt},
+        Adapter, Body, Request,
+    };
+
+    // A middleware that logs requests before forwarding them to another service
+    struct LogService<S> {
+        inner: S,
+    }
+
+    impl<S> Service<LambdaEvent<LambdaRequest>> for LogService<S>
+    where
+        S: Service<LambdaEvent<LambdaRequest>>,
+    {
+        type Response = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+
+        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+            self.inner.poll_ready(cx)
+        }
+
+        fn call(&mut self, event: LambdaEvent<LambdaRequest>) -> Self::Future {
+            // Log the request
+            println!("Lambda event: {:#?}", event);
+
+            self.inner.call(event)
+        }
+    }
+
+    /// This tests that `Adapter` can be used in a `tower::Service` where the user
+    /// may require additional middleware between `lambda_runtime::run` and where
+    /// the `LambdaEvent` is converted into a `Request`.
+    #[test]
+    fn adapter_is_boxable() {
+        let _service: BoxService<LambdaEvent<LambdaRequest>, LambdaResponse, http::Error> = ServiceBuilder::new()
+            .layer_fn(|service| {
+                // This could be any middleware that logs, inspects, or manipulates
+                // the `LambdaEvent` before it's converted to a `Request` by `Adapter`.
+
+                LogService { inner: service }
+            })
+            .layer_fn(Adapter::from)
+            .service_fn(|_event: Request| async move { Response::builder().status(StatusCode::OK).body(Body::Empty) })
+            .boxed();
+    }
+}
diff --git a/lambda-http/src/request.rs b/lambda-http/src/request.rs
@@ -61,7 +61,7 @@ impl LambdaRequest {
 }
 
 /// RequestFuture type
-pub type RequestFuture<'a, R, E> = Pin<Box<dyn Future<Output = Result<R, E>> + 'a>>;
+pub type RequestFuture<'a, R, E> = Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a>>;
 
 /// Represents the origin from which the lambda was requested from.
 #[doc(hidden)]
diff --git a/lambda-http/src/response.rs b/lambda-http/src/response.rs
@@ -129,7 +129,7 @@ pub trait IntoResponse {
 
 impl<B> IntoResponse for Response<B>
 where
-    B: ConvertBody + 'static,
+    B: ConvertBody + Send + 'static,
 {
     fn into_response(self) -> ResponseFuture {
         let (parts, body) = self.into_parts();
@@ -180,15 +180,16 @@ impl IntoResponse for serde_json::Value {
     }
 }
 
-pub type ResponseFuture = Pin<Box<dyn Future<Output = Response<Body>>>>;
+pub type ResponseFuture = Pin<Box<dyn Future<Output = Response<Body>> + Send>>;
 
 pub trait ConvertBody {
     fn convert(self, parts: HeaderMap) -> BodyFuture;
 }
 
 impl<B> ConvertBody for B
 where
-    B: HttpBody + Unpin + 'static,
+    B: HttpBody + Unpin + Send + 'static,
+    B::Data: Send,
     B::Error: fmt::Debug,
 {
     fn convert(self, headers: HeaderMap) -> BodyFuture {
@@ -227,15 +228,17 @@ where
 
 fn convert_to_binary<B>(body: B) -> BodyFuture
 where
-    B: HttpBody + Unpin + 'static,
+    B: HttpBody + Unpin + Send + 'static,
+    B::Data: Send,
     B::Error: fmt::Debug,
 {
     Box::pin(async move { Body::from(to_bytes(body).await.expect("unable to read bytes from body").to_vec()) })
 }
 
 fn convert_to_text<B>(body: B, content_type: &str) -> BodyFuture
 where
-    B: HttpBody + Unpin + 'static,
+    B: HttpBody + Unpin + Send + 'static,
+    B::Data: Send,
     B::Error: fmt::Debug,
 {
     let mime_type = content_type.parse::<Mime>();
@@ -260,7 +263,7 @@ where
     })
 }
 
-pub type BodyFuture = Pin<Box<dyn Future<Output = Body>>>;
+pub type BodyFuture = Pin<Box<dyn Future<Output = Body> + Send>>;
 
 #[cfg(test)]
 mod tests {

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ impl LambdaRequest {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`/// RequestFuture type`
`64`		`-pub type RequestFuture<'a, R, E> = Pin<Box<dyn Future<Output = Result<R, E>> + 'a>>;`
	`64`	`+pub type RequestFuture<'a, R, E> = Pin<Box<dyn Future<Output = Result<R, E>> + Send + 'a>>;`
`65`	`65`
`66`	`66`	`/// Represents the origin from which the lambda was requested from.`
`67`	`67`	`#[doc(hidden)]`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ pub trait IntoResponse {`
`129`	`129`
`130`	`130`	`impl<B> IntoResponse for Response<B>`
`131`	`131`	`where`
`132`		`- B: ConvertBody + 'static,`
	`132`	`+ B: ConvertBody + Send + 'static,`
`133`	`133`	`{`
`134`	`134`	`fn into_response(self) -> ResponseFuture {`
`135`	`135`	`let (parts, body) = self.into_parts();`
`@@ -180,15 +180,16 @@ impl IntoResponse for serde_json::Value {`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`-pub type ResponseFuture = Pin<Box<dyn Future<Output = Response<Body>>>>;`
	`183`	`+pub type ResponseFuture = Pin<Box<dyn Future<Output = Response<Body>> + Send>>;`
`184`	`184`
`185`	`185`	`pub trait ConvertBody {`
`186`	`186`	`fn convert(self, parts: HeaderMap) -> BodyFuture;`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`impl<B> ConvertBody for B`
`190`	`190`	`where`
`191`		`- B: HttpBody + Unpin + 'static,`
	`191`	`+ B: HttpBody + Unpin + Send + 'static,`
	`192`	`+ B::Data: Send,`
`192`	`193`	`B::Error: fmt::Debug,`
`193`	`194`	`{`
`194`	`195`	`fn convert(self, headers: HeaderMap) -> BodyFuture {`
`@@ -227,15 +228,17 @@ where`
`227`	`228`
`228`	`229`	`fn convert_to_binary<B>(body: B) -> BodyFuture`
`229`	`230`	`where`
`230`		`- B: HttpBody + Unpin + 'static,`
	`231`	`+ B: HttpBody + Unpin + Send + 'static,`
	`232`	`+ B::Data: Send,`
`231`	`233`	`B::Error: fmt::Debug,`
`232`	`234`	`{`
`233`	`235`	`Box::pin(async move { Body::from(to_bytes(body).await.expect("unable to read bytes from body").to_vec()) })`
`234`	`236`	`}`
`235`	`237`
`236`	`238`	`fn convert_to_text<B>(body: B, content_type: &str) -> BodyFuture`
`237`	`239`	`where`
`238`		`- B: HttpBody + Unpin + 'static,`
	`240`	`+ B: HttpBody + Unpin + Send + 'static,`
	`241`	`+ B::Data: Send,`
`239`	`242`	`B::Error: fmt::Debug,`
`240`	`243`	`{`
`241`	`244`	`let mime_type = content_type.parse::<Mime>();`
`@@ -260,7 +263,7 @@ where`
`260`	`263`	`})`
`261`	`264`	`}`
`262`	`265`
`263`		`-pub type BodyFuture = Pin<Box<dyn Future<Output = Body>>>;`
	`266`	`+pub type BodyFuture = Pin<Box<dyn Future<Output = Body> + Send>>;`
`264`	`267`
`265`	`268`	`#[cfg(test)]`
`266`	`269`	`mod tests {`