Add function to deserialize query strings

Author: tgnottingham

site/src/server.rs

@@ -284,6 +284,15 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
         return Ok(response);
     }
 
+    macro_rules! check {
+        ($e:expr) => {
+            match $e {
+                Ok(v) => v,
+                Err(e) => return Ok(e),
+            }
+        };
+    }
+
     match path {
         "/perf/info" => return server.handle_get(&req, request_handlers::handle_info),
         "/perf/dashboard" => {
@@ -303,25 +312,7 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
         }
         "/perf/triage" => {
             let input: triage::Request = if *req.method() == http::Method::GET {
-                let url = url::Url::parse(&format!("http://example.com{}", req.uri())).unwrap();
-                let parts = url
-                    .query_pairs()
-                    .into_owned()
-                    .collect::<HashMap<String, String>>();
-                match serde_json::from_str(&serde_json::to_string(&parts).unwrap()) {
-                    Ok(v) => v,
-                    Err(e) => {
-                        return Ok(http::Response::builder()
-                            .header_typed(ContentType::text_utf8())
-                            .status(StatusCode::BAD_REQUEST)
-                            .body(hyper::Body::from(format!(
-                                "failed to deserialize request {}: {:?}",
-                                req.uri(),
-                                e,
-                            )))
-                            .unwrap());
-                    }
-                }
+                check!(parse_query_string(req.uri()))
             } else if *req.method() == http::Method::POST {
                 let mut body = Vec::new();
                 let (_req, mut body_stream) = req.into_parts();
@@ -406,21 +397,12 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
         }
     }
 
-    macro_rules! body {
-        ($e:expr) => {
-            match $e {
-                Ok(v) => v,
-                Err(e) => return Ok(e),
-            }
-        };
-    }
-
     match path {
         "/perf/graph" => Ok(to_response(
-            request_handlers::handle_graph(body!(parse_body(&body)), &ctxt).await,
+            request_handlers::handle_graph(check!(parse_body(&body)), &ctxt).await,
         )),
         "/perf/get" => Ok(to_response(
-            crate::comparison::handle_compare(body!(parse_body(&body)), &ctxt)
+            crate::comparison::handle_compare(check!(parse_body(&body)), &ctxt)
                 .await
                 .map_err(|e| e.to_string()),
         )),
@@ -453,7 +435,7 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
             };
             match event.as_str() {
                 "issue_comment" => Ok(to_response(
-                    request_handlers::handle_github(body!(parse_body(&body)), ctxt.clone()).await,
+                    request_handlers::handle_github(check!(parse_body(&body)), ctxt.clone()).await,
                 )),
                 _ => Ok(http::Response::builder()
                     .status(StatusCode::OK)
@@ -462,13 +444,13 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
             }
         }
         "/perf/self-profile" => Ok(to_response(
-            request_handlers::handle_self_profile(body!(parse_body(&body)), &ctxt).await,
+            request_handlers::handle_self_profile(check!(parse_body(&body)), &ctxt).await,
         )),
         "/perf/self-profile-raw" => Ok(to_response(
-            request_handlers::handle_self_profile_raw(body!(parse_body(&body)), &ctxt).await,
+            request_handlers::handle_self_profile_raw(check!(parse_body(&body)), &ctxt).await,
         )),
         "/perf/graph-new" => Ok(
-            match request_handlers::handle_graph_new(body!(parse_body(&body)), &ctxt).await {
+            match request_handlers::handle_graph_new(check!(parse_body(&body)), &ctxt).await {
                 Ok(result) => {
                     let mut response = http::Response::builder()
                         .header_typed(ContentType::json())
@@ -489,7 +471,7 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
             },
         ),
         "/perf/bootstrap" => Ok(
-            match request_handlers::handle_bootstrap(body!(parse_body(&body)), &ctxt).await {
+            match request_handlers::handle_bootstrap(check!(parse_body(&body)), &ctxt).await {
                 Ok(result) => {
                     let mut response = http::Response::builder()
                         .header_typed(ContentType::json())
@@ -533,14 +515,42 @@ where
                 .header_typed(ContentType::text_utf8())
                 .status(StatusCode::BAD_REQUEST)
                 .body(hyper::Body::from(format!(
-                    "Failed to deserialize request; {:?}",
+                    "Failed to deserialize request: {:?}",
                     err
                 )))
                 .unwrap());
         }
     }
 }
 
+fn parse_query_string<D>(uri: &http::Uri) -> Result<D, Response>
+where
+    D: DeserializeOwned,
+{
+    let params: HashMap<String, String> = uri
+        .query()
+        .map(|v| {
+            url::form_urlencoded::parse(v.as_bytes())
+                .into_owned()
+                .collect()
+        })
+        .unwrap_or_else(HashMap::new);
+
+    match serde_json::from_str(&serde_json::to_string(&params).unwrap()) {
+        Ok(d) => Ok(d),
+        Err(err) => {
+            return Err(http::Response::builder()
+                .header_typed(ContentType::text_utf8())
+                .status(StatusCode::BAD_REQUEST)
+                .body(hyper::Body::from(format!(
+                    "Failed to deserialize request {}: {:?}",
+                    uri, err,
+                )))
+                .unwrap());
+        }
+    }
+}
+
 /// Handle the case where the path is to a static file
 fn handle_fs_path(path: &str) -> Option<http::Response<hyper::Body>> {
     let fs_path = format!(