Improve extensions API support (#593)

calavera · web-flow · commit f56c7dc6e4aa · 2023-02-01T17:39:46.000-08:00
* Improve extensions API support

- Set request content-types for JSON payloads
- Print the returned status codes in case of errors

Signed-off-by: David Calavera &lt;david.calavera@gmail.com&gt;

* Fix clippy warnings introduced in 1.67

Signed-off-by: David Calavera &lt;david.calavera@gmail.com&gt;

---------

Signed-off-by: David Calavera &lt;david.calavera@gmail.com&gt;
diff --git a/lambda-extension/src/extension.rs b/lambda-extension/src/extension.rs
@@ -253,7 +253,8 @@ where
             )?;
             let res = client.call(req).await?;
             if res.status() != http::StatusCode::OK {
-                return Err(ExtensionError::boxed("unable to initialize the logs api"));
+                let err = format!("unable to initialize the logs api: {}", res.status());
+                return Err(ExtensionError::boxed(err));
             }
             trace!("Registered extension with Logs API");
         }
@@ -288,7 +289,8 @@ where
             )?;
             let res = client.call(req).await?;
             if res.status() != http::StatusCode::OK {
-                return Err(ExtensionError::boxed("unable to initialize the telemetry api"));
+                let err = format!("unable to initialize the telemetry api: {}", res.status());
+                return Err(ExtensionError::boxed(err));
             }
             trace!("Registered extension with Telemetry API");
         }
@@ -317,30 +319,30 @@ where
 
             let ep = match ep.ready().await {
                 Ok(ep) => ep,
-                Err(error) => {
-                    println!("Inner service is not ready: {:?}", error);
+                Err(err) => {
+                    println!("Inner service is not ready: {err:?}");
                     let req = if is_invoke {
-                        requests::init_error(extension_id, &error.to_string(), None)?
+                        requests::init_error(extension_id, &err.to_string(), None)?
                     } else {
-                        requests::exit_error(extension_id, &error.to_string(), None)?
+                        requests::exit_error(extension_id, &err.to_string(), None)?
                     };
 
                     client.call(req).await?;
-                    return Err(error.into());
+                    return Err(err.into());
                 }
             };
 
             let res = ep.call(event).await;
-            if let Err(error) = res {
-                println!("{:?}", error);
+            if let Err(err) = res {
+                println!("{err:?}");
                 let req = if is_invoke {
-                    requests::init_error(extension_id, &error.to_string(), None)?
+                    requests::init_error(extension_id, &err.to_string(), None)?
                 } else {
-                    requests::exit_error(extension_id, &error.to_string(), None)?
+                    requests::exit_error(extension_id, &err.to_string(), None)?
                 };
 
                 client.call(req).await?;
-                return Err(error.into());
+                return Err(err.into());
             }
         }
         Ok(())
@@ -422,7 +424,8 @@ async fn register<'a>(
     let req = requests::register_request(&name, events)?;
     let res = client.call(req).await?;
     if res.status() != http::StatusCode::OK {
-        return Err(ExtensionError::boxed("unable to register the extension"));
+        let err = format!("unable to register the extension: {}", res.status());
+        return Err(ExtensionError::boxed(err));
     }
 
     let header = res
diff --git a/lambda-extension/src/logs.rs b/lambda-extension/src/logs.rs
@@ -174,7 +174,7 @@ where
         let mut service = service.lock().await;
         match service.call(logs).await {
             Ok(_) => (),
-            Err(err) => println!("{:?}", err),
+            Err(err) => println!("{err:?}"),
         }
     }
 
diff --git a/lambda-extension/src/requests.rs b/lambda-extension/src/requests.rs
@@ -7,6 +7,8 @@ use serde::Serialize;
 const EXTENSION_NAME_HEADER: &str = "Lambda-Extension-Name";
 pub(crate) const EXTENSION_ID_HEADER: &str = "Lambda-Extension-Identifier";
 const EXTENSION_ERROR_TYPE_HEADER: &str = "Lambda-Extension-Function-Error-Type";
+const CONTENT_TYPE_HEADER_NAME: &str = "Content-Type";
+const CONTENT_TYPE_HEADER_VALUE: &str = "application/json";
 
 pub(crate) fn next_event_request(extension_id: &str) -> Result<Request<Body>, Error> {
     let req = build_request()
@@ -24,6 +26,7 @@ pub(crate) fn register_request(extension_name: &str, events: &[&str]) -> Result<
         .method(Method::POST)
         .uri("/2020-01-01/extension/register")
         .header(EXTENSION_NAME_HEADER, extension_name)
+        .header(CONTENT_TYPE_HEADER_NAME, CONTENT_TYPE_HEADER_VALUE)
         .body(Body::from(serde_json::to_string(&events)?))?;
 
     Ok(req)
@@ -65,14 +68,15 @@ pub(crate) fn subscribe_request(
         "buffering": buffering.unwrap_or_default(),
         "destination": {
             "protocol": "HTTP",
-            "URI": format!("http://sandbox.localdomain:{}", port_number),
+            "URI": format!("http://sandbox.localdomain:{port_number}"),
         }
     });
 
     let req = build_request()
         .method(Method::PUT)
         .uri(api.uri())
         .header(EXTENSION_ID_HEADER, extension_id)
+        .header(CONTENT_TYPE_HEADER_NAME, CONTENT_TYPE_HEADER_VALUE)
         .body(Body::from(serde_json::to_string(&data)?))?;
 
     Ok(req)
@@ -91,30 +95,30 @@ pub struct ErrorRequest<'a> {
 }
 
 /// Create a new init error request to send to the Extensions API
-pub fn init_error<'a>(
+pub fn init_error(
     extension_id: &str,
     error_type: &str,
-    request: Option<ErrorRequest<'a>>,
+    request: Option<ErrorRequest<'_>>,
 ) -> Result<Request<Body>, Error> {
     error_request("init", extension_id, error_type, request)
 }
 
 /// Create a new exit error request to send to the Extensions API
-pub fn exit_error<'a>(
+pub fn exit_error(
     extension_id: &str,
     error_type: &str,
-    request: Option<ErrorRequest<'a>>,
+    request: Option<ErrorRequest<'_>>,
 ) -> Result<Request<Body>, Error> {
     error_request("exit", extension_id, error_type, request)
 }
 
-fn error_request<'a>(
+fn error_request(
     error_type: &str,
     extension_id: &str,
     error_str: &str,
-    request: Option<ErrorRequest<'a>>,
+    request: Option<ErrorRequest<'_>>,
 ) -> Result<Request<Body>, Error> {
-    let uri = format!("/2020-01-01/extension/{}/error", error_type);
+    let uri = format!("/2020-01-01/extension/{error_type}/error");
 
     let body = match request {
         None => Body::empty(),
diff --git a/lambda-extension/src/telemetry.rs b/lambda-extension/src/telemetry.rs
@@ -291,7 +291,7 @@ where
         let mut service = service.lock().await;
         match service.call(telemetry).await {
             Ok(_) => (),
-            Err(err) => println!("{:?}", err),
+            Err(err) => println!("{err:?}"),
         }
     }
 
diff --git a/lambda-http/src/ext.rs b/lambda-http/src/ext.rs
@@ -37,11 +37,10 @@ pub enum PayloadError {
 impl fmt::Display for PayloadError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            PayloadError::Json(json) => writeln!(f, "failed to parse payload from application/json {}", json),
+            PayloadError::Json(json) => writeln!(f, "failed to parse payload from application/json {json}"),
             PayloadError::WwwFormUrlEncoded(form) => writeln!(
                 f,
-                "failed to parse payload from application/x-www-form-urlencoded {}",
-                form
+                "failed to parse payload from application/x-www-form-urlencoded {form}"
             ),
         }
     }
diff --git a/lambda-http/src/request.rs b/lambda-http/src/request.rs
@@ -324,7 +324,7 @@ fn apigw_path_with_stage(stage: &Option<String>, path: &str) -> String {
     match stage {
         None => path.into(),
         Some(stage) if stage == "$default" => path.into(),
-        Some(stage) => format!("/{}{}", stage, path),
+        Some(stage) => format!("/{stage}{path}"),
     }
 }
 
@@ -418,15 +418,15 @@ fn build_request_uri(
 ) -> String {
     let mut url = match host {
         None => {
-            let rel_url = Url::parse(&format!("http://localhost{}", path)).unwrap();
+            let rel_url = Url::parse(&format!("http://localhost{path}")).unwrap();
             rel_url.path().to_string()
         }
         Some(host) => {
             let scheme = headers
                 .get(x_forwarded_proto())
                 .and_then(|s| s.to_str().ok())
                 .unwrap_or("https");
-            let url = format!("{}://{}{}", scheme, host, path);
+            let url = format!("{scheme}://{host}{path}");
             Url::parse(&url).unwrap().to_string()
         }
     };
diff --git a/lambda-runtime-api-client/src/lib.rs b/lambda-runtime-api-client/src/lib.rs
@@ -66,7 +66,7 @@ where
             (scheme, authority, base_path)
         };
         let path = parts.uri.path_and_query().expect("PathAndQuery not found");
-        let pq: PathAndQuery = format!("{}{}", base_path, path).parse().expect("PathAndQuery invalid");
+        let pq: PathAndQuery = format!("{base_path}{path}").parse().expect("PathAndQuery invalid");
 
         let uri = Uri::builder()
             .scheme(scheme.as_ref())
diff --git a/lambda-runtime/src/lib.rs b/lambda-runtime/src/lib.rs
@@ -183,7 +183,7 @@ where
                                 error!("{:?}", err);
                                 let error_type = type_name_of_val(&err);
                                 let msg = if let Some(msg) = err.downcast_ref::<&str>() {
-                                    format!("Lambda panicked: {}", msg)
+                                    format!("Lambda panicked: {msg}")
                                 } else {
                                     "Lambda panicked".to_string()
                                 };
@@ -268,7 +268,7 @@ where
 {
     error!("{:?}", err); // logs the error in CloudWatch
     let error_type = type_name_of_val(&err);
-    let msg = format!("{}", err);
+    let msg = format!("{err}");
 
     EventErrorRequest::new(request_id, error_type, &msg).into_req()
 }

Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ where`
`174`	`174`	`let mut service = service.lock().await;`
`175`	`175`	`match service.call(logs).await {`
`176`	`176`	`Ok(_) => (),`
`177`		`- Err(err) => println!("{:?}", err),`
	`177`	`+ Err(err) => println!("{err:?}"),`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`
Original file line number	Diff line number	Diff line change
`@@ -291,7 +291,7 @@ where`
`291`	`291`	`let mut service = service.lock().await;`
`292`	`292`	`match service.call(telemetry).await {`
`293`	`293`	`Ok(_) => (),`
`294`		`- Err(err) => println!("{:?}", err),`
	`294`	`+ Err(err) => println!("{err:?}"),`
`295`	`295`	`}`
`296`	`296`	`}`
`297`	`297`
Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,10 @@ pub enum PayloadError {`
`37`	`37`	`impl fmt::Display for PayloadError {`
`38`	`38`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`39`	`39`	`match self {`
`40`		`- PayloadError::Json(json) => writeln!(f, "failed to parse payload from application/json {}", json),`
	`40`	`+ PayloadError::Json(json) => writeln!(f, "failed to parse payload from application/json {json}"),`
`41`	`41`	`PayloadError::WwwFormUrlEncoded(form) => writeln!(`
`42`	`42`	`f,`
`43`		`- "failed to parse payload from application/x-www-form-urlencoded {}",`
`44`		`- form`
	`43`	`+ "failed to parse payload from application/x-www-form-urlencoded {form}"`
`45`	`44`	`),`
`46`	`45`	`}`
`47`	`46`	`}`