Create api endpoint for new status page

Author: Jamesbarford

database/src/lib.rs

@@ -807,7 +807,7 @@ pub struct ArtifactCollection {
     pub end_time: DateTime<Utc>,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub enum BenchmarkRequestStatus {
     WaitingForArtifacts,
     ArtifactsReady,
@@ -858,7 +858,7 @@ const BENCHMARK_REQUEST_TRY_STR: &str = "try";
 const BENCHMARK_REQUEST_MASTER_STR: &str = "master";
 const BENCHMARK_REQUEST_RELEASE_STR: &str = "release";
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub enum BenchmarkRequestType {
     /// A Try commit
     Try {
@@ -886,7 +886,7 @@ impl fmt::Display for BenchmarkRequestType {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct BenchmarkRequest {
     commit_type: BenchmarkRequestType,
     // When was the compiler artifact created
@@ -1051,7 +1051,7 @@ impl BenchmarkRequestIndex {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub enum BenchmarkJobStatus {
     Queued,
     InProgress {
@@ -1093,7 +1093,7 @@ impl fmt::Display for BenchmarkJobStatus {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct BenchmarkSet(u32);
 
 impl BenchmarkSet {
@@ -1108,7 +1108,7 @@ impl BenchmarkSet {
 /// Each request is split into several `BenchmarkJob`s. Collectors poll the
 /// queue and claim a job only when its `benchmark_set` matches one of the sets
 /// they are responsible for.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct BenchmarkJob {
     id: u32,
     target: Target,
@@ -1181,7 +1181,7 @@ impl BenchmarkJobConclusion {
 }
 
 /// The configuration for a collector
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct CollectorConfig {
     name: String,
     target: Target,
@@ -1219,7 +1219,7 @@ impl CollectorConfig {
 
 /// The data that can be retrived from the database directly to populate the
 /// status page
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct PartialStatusPageData {
     pub completed_requests: Vec<(BenchmarkRequest, String, Vec<String>)>,
     pub in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)>,

database/src/pool/postgres.rs

@@ -2093,7 +2093,7 @@ where
                     // perform any computations on it
                     it.get::<_, String>(10),
                     // The errors, if there are none this will be an empty vector
-                    it.get::<_, Vec<String>>(11),
+                    it.get::<_, Option<Vec<String>>>(11).unwrap_or_default(),
                 )
             })
             .collect();

site/src/api.rs

@@ -391,6 +391,21 @@ pub mod status {
     }
 }
 
+pub mod status_new {
+    use database::{BenchmarkJob, BenchmarkRequest, CollectorConfig};
+    use serde::Serialize;
+
+    #[derive(Serialize, Debug)]
+    pub struct Response {
+        /// Completed requests alongside any errors
+        pub completed: Vec<(BenchmarkRequest, Vec<String>)>,
+        /// In progress requests alongside the jobs associated with the request
+        pub in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)>,
+        /// Configuration for all collectors including ones that are inactive
+        pub collector_configs: Vec<CollectorConfig>,
+    }
+}
+
 pub mod self_profile_raw {
     use serde::{Deserialize, Serialize};
 

site/src/request_handlers.rs

@@ -5,6 +5,7 @@ mod graph;
 mod next_artifact;
 mod self_profile;
 mod status_page;
+mod status_page_new;
 
 pub use bootstrap::handle_bootstrap;
 pub use dashboard::handle_dashboard;
@@ -19,6 +20,7 @@ pub use self_profile::{
     handle_self_profile_raw_download,
 };
 pub use status_page::handle_status_page;
+pub use status_page_new::handle_status_page_new;
 
 use crate::api::{info, ServerResult};
 use crate::load::SiteCtxt;

site/src/request_handlers/status_page_new.rs

@@ -0,0 +1,35 @@
+use std::sync::Arc;
+
+use crate::api::{status_new, ServerResult};
+use crate::load::SiteCtxt;
+
+pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_new::Response> {
+    let conn = ctxt.conn().await;
+
+    let collector_configs = conn
+        .get_collector_configs()
+        .await
+        .map_err(|e| e.to_string())?;
+    // The query gives us `max_completed_requests` number of completed requests
+    // and all inprogress requests without us needing to specify
+    //
+    // TODO; for `in_progress` requests we could look at the the completed
+    // `requests`, then use the `duration_ms` to display an estimated job
+    // finish time. Could also do that on the frontend but probably makes
+    // sense to do in SQL.
+    let partial_data = conn
+        .get_status_page_data()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(status_new::Response {
+        completed: partial_data
+            .completed_requests
+            .iter()
+            // @TODO Remove this
+            .map(|it| (it.0.clone(), it.2.clone()))
+            .collect(),
+        in_progress: partial_data.in_progress,
+        collector_configs,
+    })
+}

site/src/server.rs

@@ -382,6 +382,22 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 .handle_get_async(&req, request_handlers::handle_status_page)
                 .await;
         }
+        "/perf/status_page_new" => {
+            let ctxt: Arc<SiteCtxt> = server.ctxt.read().as_ref().unwrap().clone();
+            let result = request_handlers::handle_status_page_new(ctxt).await;
+            return match result {
+                Ok(result) => Ok(http::Response::builder()
+                    .header_typed(ContentType::json())
+                    .body(hyper::Body::from(serde_json::to_string(&result).unwrap()))
+                    .unwrap()),
+                Err(err) => Ok(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/next_artifact" => {
             return server
                 .handle_get_async(&req, request_handlers::handle_next_artifact)
@@ -640,6 +656,7 @@ async fn handle_fs_path(
         | "/dashboard.html"
         | "/detailed-query.html"
         | "/help.html"
+        | "/status_new.html"
         | "/status.html" => resolve_template(relative_path).await,
         _ => match TEMPLATES.get_static_asset(relative_path, use_compression)? {
             Payload::Compressed(data) => {
@@ -714,14 +731,18 @@ fn verify_gh_sig(cfg: &Config, header: &str, body: &[u8]) -> Option<bool> {
     Some(false)
 }
 
-fn to_response<S>(result: ServerResult<S>, compression: &Option<BrotliEncoderParams>) -> Response
+fn to_response_with_content_type<S>(
+    result: ServerResult<S>,
+    content_type: ContentType,
+    compression: &Option<BrotliEncoderParams>,
+) -> Response
 where
     S: Serialize,
 {
     match result {
         Ok(result) => {
             let response = http::Response::builder()
-                .header_typed(ContentType::octet_stream())
+                .header_typed(content_type)
                 .header_typed(CacheControl::new().with_no_cache().with_no_store());
             let body = rmp_serde::to_vec_named(&result).unwrap();
             maybe_compressed_response(response, body, compression)
@@ -735,6 +756,13 @@ where
     }
 }
 
+fn to_response<S>(result: ServerResult<S>, compression: &Option<BrotliEncoderParams>) -> Response
+where
+    S: Serialize,
+{
+    to_response_with_content_type(result, ContentType::octet_stream(), compression)
+}
+
 pub fn maybe_compressed_response(
     response: http::response::Builder,
     body: Vec<u8>,