Add endpoint for single graph

Author: rylev

site/src/api.rs

@@ -42,6 +42,28 @@ pub mod dashboard {
 }
 
 pub mod graph {
+    use super::graphs::{GraphKind, Series};
+    use collector::Bound;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+    pub struct Request {
+        pub benchmark: String,
+        pub profile: String,
+        pub scenario: String,
+        pub metric: String,
+        pub start: Bound,
+        pub end: Bound,
+        pub kind: GraphKind,
+    }
+
+    #[derive(Debug, PartialEq, Clone, Serialize)]
+    pub struct Response {
+        pub series: Series,
+    }
+}
+
+pub mod graphs {
     use collector::Bound;
     use serde::{Deserialize, Serialize};
     use std::collections::{HashMap, HashSet};

site/src/load.rs

@@ -79,7 +79,7 @@ pub struct SiteCtxt {
     /// Site configuration
     pub config: Config,
     /// Cached site landing page
-    pub landing_page: ArcSwap<Option<Arc<crate::api::graph::Response>>>,
+    pub landing_page: ArcSwap<Option<Arc<crate::api::graphs::Response>>>,
     /// Index of various common queries
     pub index: ArcSwap<crate::db::Index>,
     /// Database connection pool

site/src/request_handlers.rs

@@ -9,7 +9,7 @@ mod status_page;
 pub use bootstrap::handle_bootstrap;
 pub use dashboard::handle_dashboard;
 pub use github::handle_github;
-pub use graph::handle_graphs;
+pub use graph::{handle_graph, handle_graphs};
 pub use next_commit::handle_next_commit;
 pub use self_profile::{
     handle_self_profile, handle_self_profile_processed_download, handle_self_profile_raw,

site/src/request_handlers/graph.rs

@@ -2,25 +2,31 @@ use collector::Bound;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use crate::api::graph::GraphKind;
-use crate::api::{graph, ServerResult};
+use crate::api::graphs::GraphKind;
+use crate::api::{graph, graphs, ServerResult};
 use crate::db::{self, ArtifactId, Benchmark, Profile, Scenario};
 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);
+
+    create_graph(body, ctxt).await
+}
+
 pub async fn handle_graphs(
-    body: graph::Request,
+    body: graphs::Request,
     ctxt: &SiteCtxt,
-) -> ServerResult<Arc<graph::Response>> {
-    log::info!("handle_graph({:?})", body);
+) -> ServerResult<Arc<graphs::Response>> {
+    log::info!("handle_graphs({:?})", body);
 
     let is_default_query = body
-        == graph::Request {
+        == graphs::Request {
             start: Bound::None,
             end: Bound::None,
             stat: String::from("instructions:u"),
-            kind: graph::GraphKind::Raw,
+            kind: graphs::GraphKind::Raw,
         };
 
     if is_default_query {
@@ -30,21 +36,41 @@ pub async fn handle_graphs(
         }
     }
 
-    let resp = graph_response(body, ctxt).await?;
+    let resp = create_graphs(body, 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);
+    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)),
+            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);
+    Ok(graph::Response {
+        series: graph_series,
+    })
+}
 
-async fn graph_response(
-    body: graph::Request,
+async fn create_graphs(
+    body: graphs::Request,
     ctxt: &SiteCtxt,
-) -> ServerResult<Arc<graph::Response>> {
-    let range = ctxt.data_range(body.start..=body.end);
-    let commits: Arc<Vec<_>> = Arc::new(range.into_iter().map(|c| c.into()).collect());
+) -> ServerResult<Arc<graphs::Response>> {
+    let artifact_ids = Arc::new(artifact_ids_for_range(ctxt, body.start, body.end));
     let mut benchmarks = HashMap::new();
 
     let interpolated_responses: Vec<_> = ctxt
@@ -54,7 +80,7 @@ async fn graph_response(
                 .set::<String>(Tag::Profile, Selector::All)
                 .set::<String>(Tag::Scenario, Selector::All)
                 .set::<String>(Tag::Metric, Selector::One(body.stat)),
-            commits.clone(),
+            artifact_ids.clone(),
         )
         .await?
         .into_iter()
@@ -79,8 +105,8 @@ async fn graph_response(
             .insert(scenario, graph_series);
     }
 
-    Ok(Arc::new(graph::Response {
-        commits: Arc::try_unwrap(commits)
+    Ok(Arc::new(graphs::Response {
+        commits: Arc::try_unwrap(artifact_ids)
             .unwrap()
             .into_iter()
             .map(|c| match c {
@@ -92,13 +118,18 @@ async fn graph_response(
     }))
 }
 
+fn artifact_ids_for_range(ctxt: &SiteCtxt, start: Bound, end: Bound) -> Vec<ArtifactId> {
+    let range = ctxt.data_range(start..=end);
+    range.into_iter().map(|c| c.into()).collect()
+}
+
 /// Creates a summary "benchmark" that averages the results of all other
 /// test cases per profile type
 fn create_summary(
     ctxt: &SiteCtxt,
     interpolated_responses: &[SeriesResponse<Vec<((ArtifactId, Option<f64>), IsInterpolated)>>],
     graph_kind: GraphKind,
-) -> ServerResult<HashMap<Profile, HashMap<String, graph::Series>>> {
+) -> ServerResult<HashMap<Profile, HashMap<String, graphs::Series>>> {
     let mut baselines = HashMap::new();
     let mut summary_benchmark = HashMap::new();
     let summary_query_cases = iproduct!(
@@ -152,8 +183,8 @@ fn create_summary(
 fn graph_series(
     points: impl Iterator<Item = ((ArtifactId, Option<f64>), IsInterpolated)>,
     kind: GraphKind,
-) -> graph::Series {
-    let mut graph_series = graph::Series {
+) -> graphs::Series {
+    let mut graph_series = graphs::Series {
         points: Vec::new(),
         interpolated_indices: Default::default(),
     };

site/src/server.rs

@@ -18,7 +18,7 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 pub use crate::api::{
-    self, bootstrap, comparison, dashboard, github, graph, info, self_profile, self_profile_raw,
+    self, bootstrap, comparison, dashboard, github, graphs, info, self_profile, self_profile_raw,
     status, triage, ServerResult,
 };
 use crate::db::{self, ArtifactId};
@@ -403,6 +403,23 @@ 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) => {