add api handler

Author: s7tya

site/src/api.rs

@@ -201,6 +201,62 @@ pub mod detail_sections {
     }
 }
 
+pub mod runtime_detail_graphs {
+    use crate::api::graphs::{GraphKind, Series};
+    use collector::Bound;
+    use serde::de::{DeserializeOwned, Error};
+    use serde::{Deserialize, Deserializer, Serialize};
+    use std::fmt::Formatter;
+    use std::marker::PhantomData;
+
+    #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+    pub struct Request {
+        pub start: Bound,
+        pub end: Bound,
+        pub stat: String,
+        pub benchmark: String,
+        pub scenario: String,
+        pub profile: String,
+        #[serde(deserialize_with = "vec_from_comma_separated")]
+        pub kinds: Vec<GraphKind>,
+    }
+
+    // Deserializes a comma separated list of GraphKind values
+    fn vec_from_comma_separated<'de, T: DeserializeOwned, D>(
+        deserializer: D,
+    ) -> Result<Vec<T>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct CommaSeparatedVisitor<T>(PhantomData<T>);
+
+        impl<'de, T: DeserializeOwned> serde::de::Visitor<'de> for CommaSeparatedVisitor<T> {
+            type Value = Vec<T>;
+
+            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                formatter.write_str("comma separated list of GraphKind values")
+            }
+
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                v.split(',')
+                    .map(|v| T::deserialize(serde::de::value::StrDeserializer::new(v)))
+                    .collect::<Result<Vec<T>, _>>()
+            }
+        }
+
+        deserializer.deserialize_str(CommaSeparatedVisitor(Default::default()))
+    }
+
+    #[derive(Debug, Serialize)]
+    pub struct Response {
+        pub commits: Vec<(i64, String)>,
+        pub graphs: Vec<Series>,
+    }
+}
+
 pub mod bootstrap {
     use collector::Bound;
     use hashbrown::HashMap;

site/src/request_handlers.rs

@@ -9,7 +9,10 @@ mod status_page;
 pub use bootstrap::handle_bootstrap;
 pub use dashboard::handle_dashboard;
 pub use github::handle_github;
-pub use graph::{handle_compile_detail_graphs, handle_compile_detail_sections, handle_graphs};
+pub use graph::{
+    handle_compile_detail_graphs, handle_compile_detail_sections, handle_graphs,
+    handle_runtime_detail_graphs,
+};
 pub use next_artifact::handle_next_artifact;
 pub use self_profile::{
     handle_self_profile, handle_self_profile_processed_download, handle_self_profile_raw,

site/src/request_handlers/graph.rs

@@ -5,7 +5,7 @@ use collector::Bound;
 
 use crate::api::detail_sections::CompilationSections;
 use crate::api::graphs::GraphKind;
-use crate::api::{detail_graphs, detail_sections, graphs, ServerResult};
+use crate::api::{detail_graphs, detail_sections, graphs, runtime_detail_graphs, ServerResult};
 use crate::db::{self, ArtifactId, Profile, Scenario};
 use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
@@ -121,6 +121,50 @@ pub async fn handle_compile_detail_sections(
     Ok(detail_sections::Response { before, after })
 }
 
+pub async fn handle_runtime_detail_graphs(
+    request: runtime_detail_graphs::Request,
+    ctxt: Arc<SiteCtxt>,
+) -> ServerResult<runtime_detail_graphs::Response> {
+    log::info!("handle_runtime_detail_graphs({:?})", request);
+
+    let artifact_ids = Arc::new(master_artifact_ids_for_range(
+        &ctxt,
+        request.start,
+        request.end,
+    ));
+
+    let scenario = request.scenario.parse()?;
+    let interpolated_responses: Vec<_> = ctxt
+        .statistic_series(
+            CompileBenchmarkQuery::default()
+                .benchmark(Selector::One(request.benchmark.clone()))
+                .profile(Selector::One(request.profile.parse()?))
+                .scenario(Selector::One(scenario))
+                .metric(Selector::One(request.stat.parse()?)),
+            artifact_ids.clone(),
+        )
+        .await?
+        .into_iter()
+        .map(|sr| sr.interpolate().map(|series| series.collect::<Vec<_>>()))
+        .collect();
+
+    let mut graphs = Vec::new();
+
+    let mut interpolated_responses = interpolated_responses.into_iter();
+    if let Some(response) = interpolated_responses.next() {
+        let series = response.series.into_iter().collect::<Vec<_>>();
+        for kind in request.kinds {
+            graphs.push(graph_series(series.clone().into_iter(), kind));
+        }
+    }
+    assert!(interpolated_responses.next().is_none());
+
+    Ok(runtime_detail_graphs::Response {
+        commits: artifact_ids_to_commits(artifact_ids),
+        graphs,
+    })
+}
+
 pub async fn handle_graphs(
     request: graphs::Request,
     ctxt: Arc<SiteCtxt>,

site/src/server.rs

@@ -410,6 +410,14 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 })
                 .await;
         }
+        "/perf/compare-runtime-detail-graphs" => {
+            let query = check!(parse_query_string(req.uri()));
+            return server
+                .handle_fallible_get_async(&req, &compression, |c| {
+                    request_handlers::handle_runtime_detail_graphs(query, c)
+                })
+                .await;
+        }
         "/perf/graphs" => {
             let query = check!(parse_query_string(req.uri()));
             return server