Simplify backend code of the new status page

Author: Kobzol

database/src/lib.rs

@@ -986,6 +986,10 @@ impl BenchmarkRequest {
         self.commit_date
     }
 
+    pub fn commit_type(&self) -> &BenchmarkRequestType {
+        &self.commit_type
+    }
+
     pub fn is_master(&self) -> bool {
         matches!(self.commit_type, BenchmarkRequestType::Master { .. })
     }
@@ -1249,8 +1253,8 @@ pub struct InProgressRequestWithJobs {
 }
 
 #[derive(Debug, PartialEq)]
-pub struct CompletedBenchmarkRequestWithErrors {
-    request: BenchmarkRequest,
+pub struct BenchmarkRequestWithErrors {
+    pub request: BenchmarkRequest,
     /// Benchmark (name) -> error
-    errors: HashMap<String, String>,
+    pub errors: HashMap<String, String>,
 }

database/src/pool.rs

@@ -1,8 +1,8 @@
 use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, BenchmarkJob, BenchmarkJobConclusion,
-    BenchmarkRequest, BenchmarkRequestIndex, BenchmarkRequestStatus, BenchmarkSet, CodegenBackend,
-    CollectorConfig, CompileBenchmark, CompletedBenchmarkRequestWithErrors, Target,
+    BenchmarkRequest, BenchmarkRequestIndex, BenchmarkRequestStatus, BenchmarkRequestWithErrors,
+    BenchmarkSet, CodegenBackend, CollectorConfig, CompileBenchmark, Target,
 };
 use crate::{CollectionId, Index, Profile, QueuedCommit, Scenario, Step};
 use chrono::{DateTime, Utc};
@@ -282,7 +282,7 @@ pub trait Connection: Send + Sync {
     async fn get_last_n_completed_benchmark_requests(
         &self,
         count: u64,
-    ) -> anyhow::Result<Vec<CompletedBenchmarkRequestWithErrors>>;
+    ) -> anyhow::Result<Vec<BenchmarkRequestWithErrors>>;
 
     /// Return jobs of all requests that are currently in progress, and the jobs of their parents.
     /// The keys of the hashmap contain the request tags.

database/src/pool/postgres.rs

@@ -3,9 +3,9 @@ use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkJob,
     BenchmarkJobConclusion, BenchmarkJobStatus, BenchmarkRequest, BenchmarkRequestIndex,
-    BenchmarkRequestStatus, BenchmarkRequestType, BenchmarkSet, CodegenBackend, CollectionId,
-    CollectorConfig, Commit, CommitType, CompileBenchmark, CompletedBenchmarkRequestWithErrors,
-    Date, Index, Profile, QueuedCommit, Scenario, Target, BENCHMARK_JOB_STATUS_FAILURE_STR,
+    BenchmarkRequestStatus, BenchmarkRequestType, BenchmarkRequestWithErrors, BenchmarkSet,
+    CodegenBackend, CollectionId, CollectorConfig, Commit, CommitType, CompileBenchmark, Date,
+    Index, Profile, QueuedCommit, Scenario, Target, BENCHMARK_JOB_STATUS_FAILURE_STR,
     BENCHMARK_JOB_STATUS_IN_PROGRESS_STR, BENCHMARK_JOB_STATUS_QUEUED_STR,
     BENCHMARK_JOB_STATUS_SUCCESS_STR, BENCHMARK_REQUEST_MASTER_STR, BENCHMARK_REQUEST_RELEASE_STR,
     BENCHMARK_REQUEST_STATUS_ARTIFACTS_READY_STR, BENCHMARK_REQUEST_STATUS_COMPLETED_STR,
@@ -2048,7 +2048,7 @@ where
     async fn get_last_n_completed_benchmark_requests(
         &self,
         count: u64,
-    ) -> anyhow::Result<Vec<CompletedBenchmarkRequestWithErrors>> {
+    ) -> anyhow::Result<Vec<BenchmarkRequestWithErrors>> {
         let rows = self
             .conn()
             .query(
@@ -2090,7 +2090,7 @@ where
             .into_iter()
             .map(|request| {
                 let errors = errors.remove(request.tag().unwrap()).unwrap_or_default();
-                CompletedBenchmarkRequestWithErrors { request, errors }
+                BenchmarkRequestWithErrors { request, errors }
             })
             .collect())
     }

database/src/pool/sqlite.rs

@@ -2,9 +2,9 @@ use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction}
 use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, Benchmark, BenchmarkJob, BenchmarkJobConclusion,
-    BenchmarkRequest, BenchmarkRequestIndex, BenchmarkRequestStatus, BenchmarkSet, CodegenBackend,
-    CollectionId, CollectorConfig, Commit, CommitType, CompileBenchmark,
-    CompletedBenchmarkRequestWithErrors, Date, Profile, Target,
+    BenchmarkRequest, BenchmarkRequestIndex, BenchmarkRequestStatus, BenchmarkRequestWithErrors,
+    BenchmarkSet, CodegenBackend, CollectionId, CollectorConfig, Commit, CommitType,
+    CompileBenchmark, Date, Profile, Target,
 };
 use crate::{ArtifactIdNumber, Index, QueuedCommit};
 use chrono::{DateTime, TimeZone, Utc};
@@ -1388,7 +1388,7 @@ impl Connection for SqliteConnection {
     async fn get_last_n_completed_benchmark_requests(
         &self,
         _count: u64,
-    ) -> anyhow::Result<Vec<CompletedBenchmarkRequestWithErrors>> {
+    ) -> anyhow::Result<Vec<BenchmarkRequestWithErrors>> {
         no_queue_implementation_abort!()
     }
 }

site/src/api.rs

@@ -393,102 +393,78 @@ pub mod status {
 
 pub mod status_new {
     use chrono::{DateTime, Utc};
-    use database::BenchmarkSet;
     use hashbrown::HashMap;
     use serde::Serialize;
 
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
-    pub struct BenchmarkRequestStatusUi {
-        pub state: String,
-        pub completed_at: Option<DateTime<Utc>>,
-        pub duration_s: Option<u64>,
+    pub enum BenchmarkRequestStatus {
+        Queued,
+        InProgress,
+        Completed,
     }
 
     #[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>,
+    pub enum BenchmarkRequestType {
+        Release,
+        Master,
+        Try,
     }
 
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
-    pub struct BenchmarkRequestUi {
-        pub status: BenchmarkRequestStatusUi,
-        pub request_type: BenchmarkRequestTypeUi,
-        pub commit_date: Option<DateTime<Utc>>,
+    pub struct BenchmarkRequest {
+        pub tag: String,
+        pub status: BenchmarkRequestStatus,
+        pub request_type: BenchmarkRequestType,
         pub created_at: DateTime<Utc>,
-        pub backends: Vec<String>,
-        pub profiles: String,
-        pub errors: Vec<String>,
+        pub completed_at: Option<DateTime<Utc>>,
+        pub duration_s: Option<u64>,
+        pub errors: HashMap<String, 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>,
+    pub enum BenchmarkJobStatus {
+        Queued,
+        InProgress,
+        Success,
+        Failed,
     }
 
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
-    pub struct BenchmarkJobUi {
+    pub struct BenchmarkJob {
+        pub request_tag: String,
         pub target: String,
         pub backend: String,
         pub profile: String,
-        pub request_tag: String,
-        pub benchmark_set: BenchmarkSet,
+        pub benchmark_set: u32,
         pub created_at: DateTime<Utc>,
-        pub status: BenchmarkJobStatusUi,
+        pub status: BenchmarkJobStatus,
         pub deque_counter: u32,
     }
 
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
-    pub struct BenchmarkInProgressUi {
-        pub request: BenchmarkRequestUi,
-        pub jobs: Vec<BenchmarkJobUi>,
-    }
-
-    #[derive(Serialize, Debug, Clone)]
-    #[serde(rename_all = "camelCase")]
-    pub struct CollectorConfigUi {
+    pub struct Collector {
         pub name: String,
         pub target: String,
-        pub benchmark_set: BenchmarkSet,
+        pub benchmark_set: u32,
         pub is_active: bool,
         pub last_heartbeat_at: DateTime<Utc>,
         pub date_added: DateTime<Utc>,
-    }
-
-    #[derive(Serialize, Debug, Clone)]
-    #[serde(rename_all = "camelCase")]
-    pub struct CollectorInfo {
-        /// Configuration for the collector
-        pub config: CollectorConfigUi,
-        /// Jobs that are assigned to the collector from the currently inprogress
-        /// request and possibly that request's parent.
-        pub job_ids: Vec<u32>,
+        pub jobs: Vec<BenchmarkJob>,
     }
 
     #[derive(Serialize, Debug)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
-        /// The current queue, ordered `in_progress`, ... the queue, `completed`
-        pub queue_request_tags: Vec<String>,
-        /// Hash table of request tags to requests
-        pub requests_map: HashMap<String, BenchmarkRequestUi>,
-        /// Hash table of job ids to jobs
-        pub job_map: HashMap<u32, BenchmarkJobUi>,
-        /// Hash table of benchmark set ids to CollectorInfo
-        pub collector_work_map: HashMap<u32, CollectorInfo>,
-        /// Request tag to a vector of job ids
-        pub tag_to_jobs: HashMap<String, Vec<u32>>,
+        /// The current queue, starting from the queued request that will be benchmarked at the
+        /// latest time, then the `in_progress` requests, and then the `completed` requests.
+        pub requests: Vec<BenchmarkRequest>,
+        pub collectors: Vec<Collector>,
     }
 }