Fix enqueuing and add logs

Author: Kobzol

site/src/job_queue/mod.rs

@@ -27,7 +27,7 @@ async fn create_benchmark_request_master_commits(
 ) -> anyhow::Result<()> {
     let master_commits = &ctxt.get_master_commits().commits;
     // TODO; delete at some point in the future
-    let cutoff: chrono::DateTime<Utc> = chrono::DateTime::from_str("2025-06-01T00:00:00.000Z")?;
+    let cutoff: chrono::DateTime<Utc> = chrono::DateTime::from_str("2025-07-24T00:00:00.000Z")?;
 
     for master_commit in master_commits {
         // We don't want to add masses of obsolete data
@@ -39,6 +39,7 @@ async fn create_benchmark_request_master_commits(
                 pr,
                 master_commit.time,
             );
+            log::info!("Inserting master benchmark request {benchmark:?}");
             if let Err(error) = conn.insert_benchmark_request(&benchmark).await {
                 log::error!("Failed to insert master benchmark request: {error:?}");
             }
@@ -70,6 +71,7 @@ async fn create_benchmark_request_releases(
     for (name, date_time) in releases {
         if date_time >= cutoff && !index.contains_tag(&name) {
             let release_request = BenchmarkRequest::create_release(&name, date_time);
+            log::info!("Inserting release benchmark request {release_request:?}");
             if let Err(error) = conn.insert_benchmark_request(&release_request).await {
                 log::error!("Failed to insert release benchmark request: {error}");
             }
@@ -104,9 +106,9 @@ fn sort_benchmark_requests(index: &BenchmarkRequestIndex, request_queue: &mut [B
         // just won't have a parent result available.
         if level_len == 0 {
             if cfg!(test) {
-                panic!("No commit is ready for benchmarking");
+                panic!("No master/try commit is ready for benchmarking");
             } else {
-                log::warn!("No commit is ready for benchmarking");
+                log::warn!("No master/try commit is ready for benchmarking");
                 return;
             }
         }
@@ -175,20 +177,23 @@ pub async fn build_queue(
     Ok(queue)
 }
 
-/// From a benchmark_request create all the required jobs
-pub async fn create_benchmark_jobs(
+/// Create all necessary jobs for the given benchmark request
+/// and mark it as being in progress.
+/// This is performed atomically, in a transaction.
+pub async fn enqueue_benchmark_request(
     conn: &mut dyn database::pool::Connection,
     benchmark_request: &BenchmarkRequest,
 ) -> anyhow::Result<()> {
     let mut tx = conn.transaction().await;
-    anyhow::ensure!(
-        benchmark_request.tag().is_some(),
-        "Benchmark request has no tag"
-    );
+
+    let Some(request_tag) = benchmark_request.tag() else {
+        panic!("Benchmark request {benchmark_request:?} has no tag");
+    };
+
+    log::info!("Enqueuing jobs for request {benchmark_request:?}");
 
     let backends = benchmark_request.backends()?;
     let profiles = benchmark_request.profiles()?;
-    let request_tag = benchmark_request.tag().unwrap();
 
     // Target x benchmark_set x backend x profile -> BenchmarkJob
     for target in Target::all() {
@@ -206,7 +211,7 @@ pub async fn create_benchmark_jobs(
                             benchmark_set as u32,
                         )
                         .await?;
-                    // If there is a parent, we create a job for it to. The
+                    // If there is a parent, we create a job for it too. The
                     // database will ignore it if there is already a job there.
                     // If the parent job has been deleted from the database
                     // but was already benchmarked then the collector will ignore
@@ -234,16 +239,29 @@ pub async fn create_benchmark_jobs(
     Ok(())
 }
 
-/// Enqueue the job into the job_queue
-async fn enqueue_next_job(
+/// Try to find a benchmark request that should be enqueue next, and if such request is found,
+/// enqueue it.
+async fn try_enqueue_next_benchmark_request(
     conn: &mut dyn database::pool::Connection,
     index: &mut BenchmarkRequestIndex,
 ) -> anyhow::Result<()> {
     let queue = build_queue(conn, index).await?;
+
+    #[allow(clippy::never_loop)]
     for request in queue {
-        if request.status() != BenchmarkRequestStatus::InProgress {
-            create_benchmark_jobs(conn, &request).await?;
-            break;
+        match request.status() {
+            BenchmarkRequestStatus::ArtifactsReady => {
+                enqueue_benchmark_request(conn, &request).await?;
+                break;
+            }
+            BenchmarkRequestStatus::InProgress => {
+                // TODO: Try to mark as completed
+                break;
+            }
+            BenchmarkRequestStatus::WaitingForArtifacts
+            | BenchmarkRequestStatus::Completed { .. } => {
+                unreachable!("Unexpected request {request:?} found in request queue");
+            }
         }
     }
     Ok(())
@@ -257,7 +275,7 @@ async fn cron_enqueue_jobs(site_ctxt: &Arc<SiteCtxt>) -> anyhow::Result<()> {
     create_benchmark_request_master_commits(site_ctxt, &*conn, &index).await?;
     // Put the releases into the `benchmark_requests` queue
     create_benchmark_request_releases(&*conn, &index).await?;
-    enqueue_next_job(&mut *conn, &mut index).await?;
+    try_enqueue_next_benchmark_request(&mut *conn, &mut index).await?;
     Ok(())
 }
 
@@ -274,8 +292,8 @@ pub async fn cron_main(site_ctxt: Arc<RwLock<Option<Arc<SiteCtxt>>>>, seconds: u
             guard.as_ref().cloned()
         } {
             match cron_enqueue_jobs(&ctxt_clone).await {
-                Ok(_) => log::info!("Cron job executed at: {:?}", std::time::SystemTime::now()),
-                Err(e) => log::error!("Cron job failed to execute {}", e),
+                Ok(_) => log::info!("Cron job finished"),
+                Err(e) => log::error!("Cron job failed to execute: {e:?}"),
             }
         }
     }

site/src/request_handlers/github.rs

@@ -86,6 +86,7 @@ async fn record_try_benchmark_request_without_artifacts(
     if run_new_queue() {
         let try_request =
             BenchmarkRequest::create_try_without_artifacts(pr, chrono::Utc::now(), backends, "");
+        log::info!("Inserting try benchmark request {try_request:?}");
         if let Err(e) = conn.insert_benchmark_request(&try_request).await {
             log::error!("Failed to insert try benchmark request: {}", e);
         }