update endpoints to return something more ui friendly

Jamesbarford · Jamesbarford · commit b80cbbe4ff60 · 2025-08-20T13:01:43.000+01:00
diff --git a/database/src/lib.rs b/database/src/lib.rs
@@ -821,7 +821,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,
@@ -979,6 +979,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 { .. })
     }
@@ -1094,7 +1098,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 {
@@ -1162,6 +1166,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
diff --git a/site/src/api.rs b/site/src/api.rs
@@ -392,19 +392,88 @@ pub mod status {
 }
 
 pub mod status_new {
+    use chrono::{DateTime, Utc};
     use database::{BenchmarkJob, BenchmarkRequest, CollectorConfig};
     use serde::Serialize;
 
+    #[derive(Serialize, Debug)]
+    #[serde(rename_all = "camelCase")]
+    pub struct BenchmarkRequestStatusUi {
+        pub state: String,
+        pub completed_at: Option<DateTime<Utc>>,
+    }
+
+    #[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: u32,
+        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: u32,
+        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>,
     }
 }
 
diff --git a/site/src/request_handlers/status_page_new.rs b/site/src/request_handlers/status_page_new.rs
@@ -1,8 +1,114 @@
 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 {
+    BenchmarkRequestStatusUi {
+        state: status.as_str().to_string(),
+        completed_at: match status {
+            BenchmarkRequestStatus::WaitingForArtifacts => None,
+            BenchmarkRequestStatus::ArtifactsReady => None,
+            BenchmarkRequestStatus::InProgress => None,
+            BenchmarkRequestStatus::Completed { completed_at } => Some(completed_at),
+        },
+    }
+}
+
+fn benchmark_request_type_to_ui(req: &BenchmarkRequest) -> BenchmarkRequestTypeUi {
+    let request_type_str = if req.is_release() {
+        "Release".to_string()
+    } else if req.is_master() {
+        "Master".to_string()
+    } else {
+        "Try".to_string()
+    };
+
+    BenchmarkRequestTypeUi {
+        r#type: request_type_str,
+        tag: req.tag().map(|it| it.to_string()),
+        parent_sha: req.parent_sha().map(|it| it.to_string()),
+        pr: req.pr().map(|it| *it),
+    }
+}
+
+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 {
+    match status {
+        BenchmarkJobStatus::Queued => BenchmarkJobStatusUi {
+            state: status.as_str().to_string(),
+            started_at: None,
+            completed_at: None,
+            collector_name: None,
+        },
+        BenchmarkJobStatus::InProgress {
+            started_at,
+            collector_name,
+        } => BenchmarkJobStatusUi {
+            state: status.as_str().to_string(),
+            started_at: Some(*started_at),
+            completed_at: None,
+            collector_name: Some(collector_name.clone()),
+        },
+        BenchmarkJobStatus::Completed {
+            started_at,
+            completed_at,
+            collector_name,
+            success: _,
+        } => BenchmarkJobStatusUi {
+            state: status.as_str().to_string(),
+            started_at: Some(*started_at),
+            completed_at: Some(*completed_at),
+            collector_name: Some(collector_name.clone()),
+        },
+    }
+}
+
+fn benchmark_job_to_ui(job: &BenchmarkJob) -> BenchmarkJobUi {
+    BenchmarkJobUi {
+        target: job.target().as_str().to_string(),
+        backend: job.backend().as_str().to_string(),
+        profile: job.profile().as_str().to_string(),
+        request_tag: job.request_tag().to_string(),
+        benchmark_set: job.benchmark_set().0,
+        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_string(),
+        target: config.target().as_str().to_string(),
+        benchmark_set: config.benchmark_set().0,
+        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 +118,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 +140,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.2).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,
     })
 }
