Currently benchmarked commit is at front of queue

Author: Mark-Simulacrum

database/src/pool.rs

@@ -70,6 +70,9 @@ pub trait Connection: Send + Sync {
     // an end. Otherwise returns false, indicating that we can skip it.
     async fn collector_start_step(&self, aid: ArtifactIdNumber, step: &str) -> bool;
     async fn collector_end_step(&self, aid: ArtifactIdNumber, step: &str);
+
+    // Returns an artifact that is in progress.
+    async fn in_progress_artifact(&self) -> Option<ArtifactId>;
 }
 
 #[async_trait::async_trait]

database/src/pool/postgres.rs

@@ -1,6 +1,7 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
 use crate::{
-    ArtifactIdNumber, Cache, CollectionId, Commit, Crate, Date, Index, Profile, QueuedCommit,
+    ArtifactId, ArtifactIdNumber, Cache, CollectionId, Commit, Crate, Date, Index, Profile,
+    QueuedCommit,
 };
 use anyhow::Context as _;
 use chrono::{DateTime, TimeZone, Utc};
@@ -660,9 +661,9 @@ where
             .unwrap();
     }
 
-    async fn artifact_id(&self, artifact: &crate::ArtifactId) -> ArtifactIdNumber {
+    async fn artifact_id(&self, artifact: &ArtifactId) -> ArtifactIdNumber {
         let (name, date, ty) = match artifact {
-            crate::ArtifactId::Commit(commit) => (
+            ArtifactId::Commit(commit) => (
                 commit.sha.to_string(),
                 if commit.is_try() {
                     None
@@ -671,7 +672,7 @@ where
                 },
                 if commit.is_try() { "try" } else { "master" },
             ),
-            crate::ArtifactId::Artifact(a) => (a.clone(), None, "release"),
+            ArtifactId::Artifact(a) => (a.clone(), None, "release"),
         };
 
         let aid = self.conn()
@@ -830,4 +831,37 @@ where
             log::error!("did not end {} for {:?}", step, aid);
         }
     }
+    async fn in_progress_artifact(&self) -> Option<ArtifactId> {
+        let rows = self
+            .conn()
+            .query(
+                "select distinct aid from collector_progress where end_time is null order by aid limit 1",
+                &[],
+            )
+            .await
+            .unwrap();
+        let aid = rows.into_iter().next().map(|row| row.get::<_, i16>(0))?;
+
+        let row = self
+            .conn()
+            .query_one(
+                "select name, date, type from artifact where id = $1",
+                &[&aid],
+            )
+            .await
+            .unwrap();
+
+        let ty = row.get::<_, String>(2);
+        Some(match ty.as_str() {
+            "try" | "master" => ArtifactId::Commit(Commit {
+                sha: row.get(0),
+                date: Date(row.get(1)),
+            }),
+            "release" => ArtifactId::Artifact(row.get(0)),
+            _ => {
+                log::error!("unknown ty {:?}", ty);
+                return None;
+            }
+        })
+    }
 }

database/src/pool/sqlite.rs

@@ -1,6 +1,6 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::{ArtifactId, CollectionId, Commit, Crate, Date, Profile};
 use crate::{ArtifactIdNumber, Index, QueryDatum, QueuedCommit};
-use crate::{CollectionId, Commit, Crate, Date, Profile};
 use chrono::{TimeZone, Utc};
 use hashbrown::HashMap;
 use rusqlite::params;
@@ -675,4 +675,45 @@ impl Connection for SqliteConnection {
             log::error!("did not end {} for {:?}", step, aid);
         }
     }
+    async fn in_progress_artifact(&self) -> Option<ArtifactId> {
+        let aid = self
+            .raw_ref()
+            .query_row(
+                "select distinct aid from collector_progress where end is null order by aid limit 1",
+                params![],
+                |r| r.get::<_, i16>(0),
+            )
+            .optional()
+            .unwrap()?;
+
+        let (name, date, ty) = self
+            .raw_ref()
+            .query_row(
+                "select name, date, type from artifact where id = ?",
+                params![&aid],
+                |r| {
+                    Ok((
+                        r.get::<_, String>(0)?,
+                        r.get::<_, Option<i64>>(1)?,
+                        r.get::<_, String>(2)?,
+                    ))
+                },
+            )
+            .unwrap();
+
+        Some(match ty.as_str() {
+            "try" | "master" => ArtifactId::Commit(Commit {
+                sha: name,
+                date: date
+                    .map(|d| Utc.timestamp(d, 0))
+                    .map(Date)
+                    .unwrap_or_else(|| Date::ymd_hms(2001, 01, 01, 0, 0, 0)),
+            }),
+            "release" => ArtifactId::Artifact(name),
+            _ => {
+                log::error!("unknown ty {:?}", ty);
+                return None;
+            }
+        })
+    }
 }

site/src/load.rs

@@ -34,6 +34,7 @@ pub enum MissingReason {
     Sha,
     TryParent,
     TryCommit,
+    InProgress,
 }
 
 #[derive(Clone, Deserialize, Serialize, Debug)]
@@ -151,9 +152,8 @@ impl InputData {
             .context("getting master commit list")
             .unwrap();
 
-        let have = self
-            .index
-            .load()
+        let index = self.index.load();
+        let have = index
             .commits()
             .iter()
             .map(|commit| commit.sha.clone())
@@ -208,6 +208,26 @@ impl InputData {
             .chain(missing)
             .collect::<Vec<_>>();
 
+        match self.conn().await.in_progress_artifact().await {
+            None => {}
+            Some(ArtifactId::Commit(c)) => {
+                commits.insert(
+                    0,
+                    (
+                        rustc_artifacts::Commit {
+                            sha: c.sha,
+                            time: c.date.0,
+                        },
+                        MissingReason::InProgress,
+                    ),
+                );
+            }
+            Some(ArtifactId::Artifact(_)) => {
+                // do nothing, for now, though eventually we'll want an artifact
+                // queue
+            }
+        }
+
         let mut seen = HashSet::with_capacity(commits.len());
 
         // FIXME: replace with Vec::drain_filter when it stabilizes