Make graph(s) endpoints GET requests

Author: rylev

site/src/request_handlers/graph.rs

@@ -9,19 +9,22 @@ use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
 use crate::selector::{Query, Selector, SeriesResponse, Tag};
 
-pub async fn handle_graph(body: graph::Request, ctxt: &SiteCtxt) -> ServerResult<graph::Response> {
-    log::info!("handle_graph({:?})", body);
+pub async fn handle_graph(
+    request: graph::Request,
+    ctxt: Arc<SiteCtxt>,
+) -> ServerResult<graph::Response> {
+    log::info!("handle_graph({:?})", request);
 
-    create_graph(body, ctxt).await
+    create_graph(request, ctxt).await
 }
 
 pub async fn handle_graphs(
-    body: graphs::Request,
-    ctxt: &SiteCtxt,
+    request: graphs::Request,
+    ctxt: Arc<SiteCtxt>,
 ) -> ServerResult<Arc<graphs::Response>> {
-    log::info!("handle_graphs({:?})", body);
+    log::info!("handle_graphs({:?})", request);
 
-    let is_default_query = body
+    let is_default_query = request
         == graphs::Request {
             start: Bound::None,
             end: Bound::None,
@@ -36,41 +39,45 @@ pub async fn handle_graphs(
         }
     }
 
-    let resp = create_graphs(body, ctxt).await?;
+    let resp = create_graphs(request, &ctxt).await?;
 
     if is_default_query {
         ctxt.landing_page.store(Arc::new(Some(resp.clone())));
     }
 
     Ok(resp)
 }
-async fn create_graph(body: graph::Request, ctxt: &SiteCtxt) -> ServerResult<graph::Response> {
-    let artifact_ids = artifact_ids_for_range(ctxt, body.start, body.end);
+
+async fn create_graph(
+    request: graph::Request,
+    ctxt: Arc<SiteCtxt>,
+) -> ServerResult<graph::Response> {
+    let artifact_ids = artifact_ids_for_range(&ctxt, request.start, request.end);
     let mut series_iterator = ctxt
         .statistic_series(
             Query::new()
-                .set::<String>(Tag::Benchmark, Selector::One(body.benchmark))
-                .set::<String>(Tag::Profile, Selector::One(body.profile))
-                .set::<String>(Tag::Scenario, Selector::One(body.scenario))
-                .set::<String>(Tag::Metric, Selector::One(body.metric)),
+                .set::<String>(Tag::Benchmark, Selector::One(request.benchmark))
+                .set::<String>(Tag::Profile, Selector::One(request.profile))
+                .set::<String>(Tag::Scenario, Selector::One(request.scenario))
+                .set::<String>(Tag::Metric, Selector::One(request.metric)),
             Arc::new(artifact_ids),
         )
         .await?
         .into_iter()
         .map(SeriesResponse::interpolate);
 
     let result = series_iterator.next().unwrap();
-    let graph_series = graph_series(result.series, body.kind);
+    let graph_series = graph_series(result.series, request.kind);
     Ok(graph::Response {
         series: graph_series,
     })
 }
 
 async fn create_graphs(
-    body: graphs::Request,
+    request: graphs::Request,
     ctxt: &SiteCtxt,
 ) -> ServerResult<Arc<graphs::Response>> {
-    let artifact_ids = Arc::new(artifact_ids_for_range(ctxt, body.start, body.end));
+    let artifact_ids = Arc::new(artifact_ids_for_range(ctxt, request.start, request.end));
     let mut benchmarks = HashMap::new();
 
     let interpolated_responses: Vec<_> = ctxt
@@ -79,23 +86,23 @@ async fn create_graphs(
                 .set::<String>(Tag::Benchmark, Selector::All)
                 .set::<String>(Tag::Profile, Selector::All)
                 .set::<String>(Tag::Scenario, Selector::All)
-                .set::<String>(Tag::Metric, Selector::One(body.stat)),
+                .set::<String>(Tag::Metric, Selector::One(request.stat)),
             artifact_ids.clone(),
         )
         .await?
         .into_iter()
         .map(|sr| sr.interpolate().map(|series| series.collect::<Vec<_>>()))
         .collect();
 
-    let summary_benchmark = create_summary(ctxt, &interpolated_responses, body.kind)?;
+    let summary_benchmark = create_summary(ctxt, &interpolated_responses, request.kind)?;
 
     benchmarks.insert("Summary".to_string(), summary_benchmark);
 
     for response in interpolated_responses {
         let benchmark = response.path.get::<Benchmark>()?.to_string();
         let profile = *response.path.get::<Profile>()?;
         let scenario = response.path.get::<Scenario>()?.to_string();
-        let graph_series = graph_series(response.series.into_iter(), body.kind);
+        let graph_series = graph_series(response.series.into_iter(), request.kind);
 
         benchmarks
             .entry(benchmark)

site/src/server.rs

@@ -131,6 +131,39 @@ impl Server {
             .unwrap())
     }
 
+    async fn handle_fallible_get_async<F, R, S, E>(
+        &self,
+        req: &Request,
+        handler: F,
+    ) -> Result<Response, ServerError>
+    where
+        F: FnOnce(Arc<SiteCtxt>) -> R,
+        R: std::future::Future<Output = Result<S, E>> + Send,
+        S: Serialize,
+        E: Into<Vec<u8>>,
+    {
+        check_http_method!(*req.method(), http::Method::GET);
+        let ctxt = self.ctxt.clone();
+        let ctxt = ctxt.read().as_ref().unwrap().clone();
+        let result = handler(ctxt).await;
+        let response = match result {
+            Ok(result) => {
+                let response = http::Response::builder()
+                    .header_typed(ContentType::json())
+                    .header_typed(CacheControl::new().with_no_cache().with_no_store());
+                let body = serde_json::to_vec(&result).unwrap();
+                response.body(hyper::Body::from(body)).unwrap()
+            }
+            Err(err) => http::Response::builder()
+                .status(StatusCode::INTERNAL_SERVER_ERROR)
+                .header_typed(ContentType::text_utf8())
+                .header_typed(CacheControl::new().with_no_cache().with_no_store())
+                .body(hyper::Body::from(err.into()))
+                .unwrap(),
+        };
+        Ok(response)
+    }
+
     fn check_auth(&self, req: &http::request::Parts) -> bool {
         if let Some(auth) = req
             .headers
@@ -317,6 +350,18 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 crate::comparison::handle_triage(input, &ctxt).await,
             ));
         }
+        "/perf/graph" => {
+            let query = check!(parse_query_string(req.uri()));
+            return server
+                .handle_fallible_get_async(&req, |c| request_handlers::handle_graph(query, c))
+                .await;
+        }
+        "/perf/graphs" => {
+            let query = check!(parse_query_string(req.uri()));
+            return server
+                .handle_fallible_get_async(&req, |c| request_handlers::handle_graphs(query, c))
+                .await;
+        }
         "/perf/metrics" => {
             return Ok(server.handle_metrics(req).await);
         }
@@ -403,40 +448,6 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
         "/perf/self-profile-raw" => Ok(to_response(
             request_handlers::handle_self_profile_raw(check!(parse_body(&body)), &ctxt).await,
         )),
-        "/perf/graph" => Ok(
-            match request_handlers::handle_graph(check!(parse_body(&body)), &ctxt).await {
-                Ok(result) => {
-                    let response = http::Response::builder()
-                        .header_typed(ContentType::json())
-                        .header_typed(CacheControl::new().with_no_cache().with_no_store());
-                    let body = serde_json::to_vec(&result).unwrap();
-                    response.body(hyper::Body::from(body)).unwrap()
-                }
-                Err(err) => http::Response::builder()
-                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                    .header_typed(ContentType::text_utf8())
-                    .header_typed(CacheControl::new().with_no_cache().with_no_store())
-                    .body(hyper::Body::from(err))
-                    .unwrap(),
-            },
-        ),
-        "/perf/graphs" => Ok(
-            match request_handlers::handle_graphs(check!(parse_body(&body)), &ctxt).await {
-                Ok(result) => {
-                    let response = http::Response::builder()
-                        .header_typed(ContentType::json())
-                        .header_typed(CacheControl::new().with_no_cache().with_no_store());
-                    let body = serde_json::to_vec(&result).unwrap();
-                    response.body(hyper::Body::from(body)).unwrap()
-                }
-                Err(err) => http::Response::builder()
-                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                    .header_typed(ContentType::text_utf8())
-                    .header_typed(CacheControl::new().with_no_cache().with_no_store())
-                    .body(hyper::Body::from(err))
-                    .unwrap(),
-            },
-        ),
         "/perf/bootstrap" => Ok(
             match request_handlers::handle_bootstrap(check!(parse_body(&body)), &ctxt).await {
                 Ok(result) => {

site/static/index.html

@@ -387,11 +387,9 @@ <h3>This may take a while!</h3>
             document.querySelector("#loading").style.display = 'none';
         }
 
-        function post_json(path, body) {
-            return fetch(BASE_URL + path, {
-                method: "POST",
-                body: JSON.stringify(body),
-            }).then(r => r.json());
+        function get_json(path, query) {
+            let q = Object.entries(query).map(e => `${e[0]}=${e[1]}`).join("&");
+            return fetch(BASE_URL + path + "?" + q).then(r => r.json());
         }
 
         function prepData(data) {
@@ -439,7 +437,7 @@ <h3>This may take a while!</h3>
                 stat: "instructions:u",
                 kind: "raw",
             }, state);
-            post_json("/graphs", values).then(prepData).then(data =>
+            get_json("/graphs", values).then(prepData).then(data =>
                 renderPlots(data, values));
         });
     </script>