update endpoints to return something more ui friendly

Author: Jamesbarford

database/src/lib.rs

@@ -199,7 +199,7 @@ impl Ord for Commit {
 
 /// The compilation profile (i.e., how the crate was built)
 #[derive(
-    Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
+    Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Deserialize, serde::Serialize,
 )]
 pub enum Profile {
     /// A checked build (i.e., no codegen)
@@ -356,9 +356,7 @@ impl PartialOrd for Scenario {
 /// https://doc.rust-lang.org/nightly/rustc/platform-support.html
 ///
 /// Presently we only support x86_64
-#[derive(
-    Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum Target {
     /// `x86_64-unknown-linux-gnu`
     X86_64UnknownLinuxGnu,
@@ -393,9 +391,7 @@ impl fmt::Display for Target {
 }
 
 /// The codegen backend used for compilation.
-#[derive(
-    Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum CodegenBackend {
     /// The default LLVM backend
     Llvm,
@@ -807,7 +803,7 @@ pub struct ArtifactCollection {
     pub end_time: DateTime<Utc>,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum BenchmarkRequestStatus {
     WaitingForArtifacts,
     ArtifactsReady,
@@ -824,7 +820,7 @@ const BENCHMARK_REQUEST_STATUS_IN_PROGRESS_STR: &str = "in_progress";
 const BENCHMARK_REQUEST_STATUS_COMPLETED_STR: &str = "completed";
 
 impl BenchmarkRequestStatus {
-    pub(crate) fn as_str(&self) -> &str {
+    pub fn as_str(&self) -> &str {
         match self {
             Self::WaitingForArtifacts => BENCHMARK_REQUEST_STATUS_WAITING_FOR_ARTIFACTS_STR,
             Self::ArtifactsReady => BENCHMARK_REQUEST_STATUS_ARTIFACTS_READY_STR,
@@ -865,7 +861,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, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum BenchmarkRequestType {
     /// A Try commit
     Try {
@@ -893,7 +889,7 @@ impl fmt::Display for BenchmarkRequestType {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BenchmarkRequest {
     commit_type: BenchmarkRequestType,
     // When was the compiler artifact created
@@ -986,6 +982,10 @@ impl BenchmarkRequest {
         self.created_at
     }
 
+    pub fn commit_date(&self) -> Option<DateTime<Utc>> {
+        self.commit_date
+    }
+
     pub fn is_master(&self) -> bool {
         matches!(self.commit_type, BenchmarkRequestType::Master { .. })
     }
@@ -1058,7 +1058,7 @@ impl BenchmarkRequestIndex {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum BenchmarkJobStatus {
     Queued,
     InProgress {
@@ -1101,7 +1101,7 @@ impl fmt::Display for BenchmarkJobStatus {
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
-pub struct BenchmarkSet(u32);
+pub struct BenchmarkSet(pub u32);
 
 impl BenchmarkSet {
     pub fn new(id: u32) -> Self {
@@ -1115,7 +1115,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, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BenchmarkJob {
     id: u32,
     target: Target,
@@ -1169,6 +1169,10 @@ impl BenchmarkJob {
     pub fn status(&self) -> &BenchmarkJobStatus {
         &self.status
     }
+
+    pub fn created_at(&self) -> DateTime<Utc> {
+        self.created_at
+    }
 }
 
 /// Describes the final state of a job
@@ -1188,7 +1192,7 @@ impl BenchmarkJobConclusion {
 }
 
 /// The configuration for a collector
-#[derive(Debug, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, PartialEq)]
 pub struct CollectorConfig {
     name: String,
     target: Target,
@@ -1226,7 +1230,7 @@ impl CollectorConfig {
 
 /// The data that can be retrived from the database directly to populate the
 /// status page
-#[derive(Debug, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, PartialEq)]
 pub struct PartialStatusPageData {
     /// A Vector of; completed requests with any associated errors
     pub completed_requests: Vec<(BenchmarkRequest, Vec<String>)>,

site/src/api.rs

@@ -392,19 +392,89 @@ pub mod status {
 }
 
 pub mod status_new {
-    use database::{BenchmarkJob, BenchmarkRequest, CollectorConfig};
+    use chrono::{DateTime, Utc};
+    use database::BenchmarkSet;
     use serde::Serialize;
 
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkRequestStatusUi {
+        pub state: String,
+        pub completed_at: Option<DateTime<Utc>>,
+        pub duration: Option<u32>,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkRequestTypeUi {
+        pub r#type: String,
+        pub tag: Option<String>,
+        pub parent_sha: Option<String>,
+        pub pr: Option<u32>,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkRequestUi {
+        pub status: BenchmarkRequestStatusUi,
+        pub request_type: BenchmarkRequestTypeUi,
+        pub commit_date: Option<DateTime<Utc>>,
+        pub created_at: DateTime<Utc>,
+        pub backends: Vec<String>,
+        pub profiles: String,
+        pub errors: Vec<String>,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkJobStatusUi {
+        pub state: String,
+        pub started_at: Option<DateTime<Utc>>,
+        pub completed_at: Option<DateTime<Utc>>,
+        pub collector_name: Option<String>,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkJobUi {
+        pub target: String,
+        pub backend: String,
+        pub profile: String,
+        pub request_tag: String,
+        pub benchmark_set: BenchmarkSet,
+        pub created_at: DateTime<Utc>,
+        pub status: BenchmarkJobStatusUi,
+        pub deque_counter: u32,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkInProgressUi {
+        pub request: BenchmarkRequestUi,
+        pub jobs: Vec<BenchmarkJobUi>,
+    }
+
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct CollectorConfigUi {
+        pub name: String,
+        pub target: String,
+        pub benchmark_set: BenchmarkSet,
+        pub is_active: bool,
+        pub last_heartbeat_at: DateTime<Utc>,
+        pub date_added: DateTime<Utc>,
+    }
+
     #[derive(Serialize, Debug)]
     pub struct Response {
         /// Completed requests alongside any errors
-        pub completed: Vec<(BenchmarkRequest, Vec<String>)>,
+        pub completed: Vec<BenchmarkRequestUi>,
         /// In progress requests alongside the jobs associated with the request
-        pub in_progress: Vec<(BenchmarkRequest, Vec<BenchmarkJob>)>,
+        pub in_progress: Vec<BenchmarkInProgressUi>,
         /// Configuration for all collectors including ones that are inactive
-        pub collector_configs: Vec<CollectorConfig>,
+        pub collector_configs: Vec<CollectorConfigUi>,
         /// The current queue
-        pub queue: Vec<BenchmarkRequest>,
+        pub queue: Vec<BenchmarkRequestUi>,
     }
 }
 

site/src/request_handlers/status_page_new.rs

@@ -1,8 +1,107 @@
 use std::sync::Arc;
 
+use crate::api::status_new::{
+    BenchmarkInProgressUi, BenchmarkJobStatusUi, BenchmarkJobUi, BenchmarkRequestStatusUi,
+    BenchmarkRequestTypeUi, BenchmarkRequestUi, CollectorConfigUi,
+};
 use crate::api::{status_new, ServerResult};
 use crate::job_queue::build_queue;
 use crate::load::SiteCtxt;
+use database::{
+    BenchmarkJob, BenchmarkJobStatus, BenchmarkRequest, BenchmarkRequestStatus, CollectorConfig,
+};
+
+fn benchmark_request_status_to_ui(status: BenchmarkRequestStatus) -> BenchmarkRequestStatusUi {
+    let (completed_at, duration) = match status {
+        BenchmarkRequestStatus::Completed {
+            duration,
+            completed_at,
+        } => (Some(completed_at), u32::try_from(duration.as_millis()).ok()),
+        _ => (None, None),
+    };
+
+    BenchmarkRequestStatusUi {
+        state: status.as_str().to_owned(),
+        completed_at,
+        duration,
+    }
+}
+
+fn benchmark_request_type_to_ui(req: &BenchmarkRequest) -> BenchmarkRequestTypeUi {
+    BenchmarkRequestTypeUi {
+        r#type: match (req.is_release(), req.is_master()) {
+            (true, _) => "Release",
+            (_, true) => "Master",
+            _ => "Try",
+        }
+        .to_owned(),
+        tag: req.tag().map(|it| it.to_owned()),
+        parent_sha: req.parent_sha().map(|it| it.to_owned()),
+        pr: req.pr().copied(),
+    }
+}
+
+fn benchmark_request_to_ui(
+    req: &BenchmarkRequest,
+    errors: Vec<String>,
+) -> anyhow::Result<BenchmarkRequestUi> {
+    Ok(BenchmarkRequestUi {
+        status: benchmark_request_status_to_ui(req.status()),
+        request_type: benchmark_request_type_to_ui(req),
+        commit_date: req.commit_date(),
+        created_at: req.created_at(),
+        backends: req.backends()?.iter().map(|it| it.to_string()).collect(),
+        profiles: req.profiles()?.iter().map(|it| it.to_string()).collect(),
+        errors,
+    })
+}
+
+fn benchmark_job_status_to_ui(status: &BenchmarkJobStatus) -> BenchmarkJobStatusUi {
+    let (started_at, completed_at, collector_name_ref) = match status {
+        BenchmarkJobStatus::Queued => (None, None, None),
+        BenchmarkJobStatus::InProgress {
+            started_at,
+            collector_name,
+        } => (Some(*started_at), None, Some(collector_name)),
+        BenchmarkJobStatus::Completed {
+            started_at,
+            completed_at,
+            collector_name,
+            ..
+        } => (Some(*started_at), Some(*completed_at), Some(collector_name)),
+    };
+
+    BenchmarkJobStatusUi {
+        state: status.as_str().to_owned(),
+        started_at,
+        completed_at,
+        collector_name: collector_name_ref.cloned(),
+    }
+}
+
+fn benchmark_job_to_ui(job: &BenchmarkJob) -> BenchmarkJobUi {
+    BenchmarkJobUi {
+        target: job.target().as_str().to_owned(),
+        backend: job.backend().as_str().to_owned(),
+        profile: job.profile().as_str().to_owned(),
+        request_tag: job.request_tag().to_owned(),
+        benchmark_set: job.benchmark_set(),
+        created_at: job.created_at(),
+        status: benchmark_job_status_to_ui(job.status()),
+        deque_counter: job.deque_count(),
+    }
+}
+
+fn collector_config_to_ui(config: &CollectorConfig) -> CollectorConfigUi {
+    CollectorConfigUi {
+        name: config.name().to_owned(),
+        target: config.target().as_str().to_owned(),
+        benchmark_set: config.benchmark_set(),
+        is_active: config.is_active(),
+        last_heartbeat_at: config.last_heartbeat_at(),
+        date_added: config.date_added(),
+    }
+}
 
 pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_new::Response> {
     let conn = ctxt.conn().await;
@@ -12,11 +111,14 @@ pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_
     let collector_configs = conn
         .get_collector_configs()
         .await
-        .map_err(error_to_string)?;
+        .map_err(error_to_string)?
+        .iter()
+        .map(collector_config_to_ui)
+        .collect();
     // 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
+    // @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.
@@ -31,15 +133,28 @@ pub async fn handle_status_page_new(ctxt: Arc<SiteCtxt>) -> ServerResult<status_
     // @TODO; do we need both the queue and the inprogress jobs from the database?
     let queue = build_queue(&*conn, &index).await.map_err(error_to_string)?;
 
+    let mut completed: Vec<BenchmarkRequestUi> = vec![];
+    for it in partial_data.completed_requests {
+        completed.push(benchmark_request_to_ui(&it.0, it.1).map_err(error_to_string)?);
+    }
+
+    let mut in_progress: Vec<BenchmarkInProgressUi> = vec![];
+    for it in partial_data.in_progress {
+        in_progress.push(BenchmarkInProgressUi {
+            request: benchmark_request_to_ui(&it.0, vec![]).map_err(error_to_string)?,
+            jobs: it.1.iter().map(benchmark_job_to_ui).collect(),
+        });
+    }
+
+    let mut queue_ui: Vec<BenchmarkRequestUi> = vec![];
+    for it in queue {
+        queue_ui.push(benchmark_request_to_ui(&it, vec![]).map_err(error_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,
+        completed,
+        in_progress,
         collector_configs,
-        queue,
+        queue: queue_ui,
     })
 }