Merge pull request #45 from awslabs/dev

bnusunny · web-flow · commit 3440e4448035 · 2022-07-18T11:43:09.000+08:00
readness_check_port defaults to port
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -1 +1 @@
-max_width=160
+max_width=120
diff --git a/src/main.rs b/src/main.rs
@@ -11,10 +11,28 @@ use tokio_retry::{strategy::FixedInterval, Retry};
 
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
+struct AdapterOptions {
+    host: String,
+    port: String,
+    readiness_check_port: String,
+    readiness_check_path: String,
+    base_path: Option<String>,
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Error> {
     env_logger::init();
 
+    // setup config options from environment variables
+    let options = &AdapterOptions {
+        host: env::var("HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
+        port: env::var("PORT").unwrap_or_else(|_| "8080".to_string()),
+        readiness_check_port: env::var("READINESS_CHECK_PORT")
+            .unwrap_or_else(|_| env::var("PORT").unwrap_or_else(|_| "8080".to_string())),
+        readiness_check_path: env::var("READINESS_CHECK_PATH").unwrap_or_else(|_| "/".to_string()),
+        base_path: env::var("REMOVE_BASE_PATH").ok(),
+    };
+
     // register as an external extension
     let handle = Handle::current();
     tokio::task::spawn_blocking(move || {
@@ -31,48 +49,41 @@ async fn main() -> Result<(), Error> {
     // check if the application is ready every 10 milliseconds
     Retry::spawn(FixedInterval::from_millis(10), || {
         let readiness_check_url = format!(
-            "http://127.0.0.1:{}{}",
-            env::var("READINESS_CHECK_PORT").unwrap_or_else(|_| "8080".to_string()),
-            env::var("READINESS_CHECK_PATH").unwrap_or_else(|_| "/".to_string())
+            "http://{}:{}{}",
+            options.host, options.readiness_check_port, options.readiness_check_path
         );
         reqwest::get(readiness_check_url)
     })
     .await?;
 
     // start lambda runtime
-    let options = &HandlerOptions {
-        http_client: Client::builder().redirect(redirect::Policy::none()).build().unwrap(),
-        host: env::var("HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
-        port: env::var("PORT").unwrap_or_else(|_| "8080".to_string()),
-        base_path: env::var("REMOVE_BASE_PATH").unwrap_or_default(),
-    };
-    lambda_http::run(http_handler(move |event: Request| async move { http_proxy_handler(event, options).await })).await?;
+    let http_client = &Client::builder().redirect(redirect::Policy::none()).build().unwrap();
+    lambda_http::run(http_handler(|event: Request| async move {
+        http_proxy_handler(event, http_client, options).await
+    }))
+    .await?;
     Ok(())
 }
 
-struct HandlerOptions {
-    http_client: Client,
-    host: String,
-    port: String,
-    base_path: String,
-}
-
-async fn http_proxy_handler(event: Request, options: &HandlerOptions) -> Result<Response<Body>, Error> {
+async fn http_proxy_handler(
+    event: Request,
+    http_client: &Client,
+    options: &AdapterOptions,
+) -> Result<Response<Body>, Error> {
     let host = options.host.as_str();
     let port = options.port.as_str();
     let (parts, body) = event.into_parts();
     let mut path_and_query = parts.uri.path_and_query().unwrap().as_str();
     // strip away Base Path if environment variable REMOVE_BASE_PATH is set.
-    if options.base_path != String::default() {
-        if let Some(value) = path_and_query.strip_prefix(options.base_path.as_str()) {
+    if options.base_path.is_some() {
+        if let Some(value) = path_and_query.strip_prefix(options.base_path.as_ref().unwrap()) {
             path_and_query = value;
         };
     }
     let app_url = format!("http://{}:{}{}", host, port, path_and_query);
     debug!("app_url is {:#?}", app_url);
 
-    let app_response = options
-        .http_client
+    let app_response = http_client
         .request(parts.method, app_url)
         .headers(parts.headers)
         .body(body.to_vec())
