Rescan tech review reports when a new version of Delphi is ran

apps/labrinth/src/database/models/delphi_report_item.rs

@@ -182,6 +182,27 @@ pub struct DelphiReportIssueResult {
 }
 
 impl DBDelphiReportIssue {
+    pub async fn upsert(
+        &self,
+        transaction: &mut PgTransaction<'_>,
+    ) -> Result<DelphiReportIssueId, DatabaseError> {
+        Ok(DelphiReportIssueId(
+            sqlx::query_scalar!(
+                "
+                INSERT INTO delphi_report_issues (report_id, issue_type)
+                VALUES ($1, $2)
+                ON CONFLICT (report_id, issue_type) DO UPDATE SET
+                    issue_type = EXCLUDED.issue_type
+                RETURNING id
+                ",
+                self.report_id as DelphiReportId,
+                self.issue_type,
+            )
+            .fetch_one(&mut *transaction)
+            .await?,
+        ))
+    }
+
     pub async fn insert(
         &self,
         transaction: &mut PgTransaction<'_>,

apps/labrinth/src/lib.rs

@@ -19,6 +19,7 @@ use crate::database::{PgPool, ReadOnlyPgPool};
 use crate::env::ENV;
 use crate::queue::billing::{index_billing, index_subscriptions};
 use crate::queue::moderation::AutomatedModerationQueue;
+use crate::routes::internal::delphi::rescan::rescan_projects_in_queue;
 use crate::util::anrok;
 use crate::util::archon::ArchonClient;
 use crate::util::ratelimit::{AsyncRateLimiter, GCRAParameters};
@@ -102,6 +103,15 @@ pub fn app_setup(
 
     let scheduler = scheduler::Scheduler::new();
 
+    {
+        let pool_ref = pool.clone();
+        actix_rt::spawn(async move {
+            if let Err(err) = rescan_projects_in_queue(&pool_ref).await {
+                warn!("Delphi rescan failed: {err:#}");
+            }
+        });
+    }
+
     let limiter = web::Data::new(AsyncRateLimiter::new(
         redis_pool.clone(),
         GCRAParameters::new(300, 300),

apps/labrinth/src/routes/internal/delphi.rs → apps/labrinth/src/routes/internal/delphi/mod.rs

@@ -34,6 +34,8 @@ use crate::{
     util::{error::Context, guards::admin_key_guard},
 };
 
+pub mod rescan;
+
 pub fn config(cfg: &mut web::ServiceConfig) {
     cfg.service(
         web::scope("delphi")
@@ -197,7 +199,10 @@ async fn ingest_report_deserialized(
 
     report.send_to_slack(&pool, &redis).await.ok();
 
-    let mut transaction = pool.begin().await?;
+    let mut transaction = pool
+        .begin()
+        .await
+        .wrap_internal_err("failed to begin Delphi ingest transaction")?;
 
     let report_id = DBDelphiReport {
         id: DelphiReportId(0), // This will be set by the database
@@ -208,7 +213,8 @@ async fn ingest_report_deserialized(
         severity: report.severity,
     }
     .upsert(&mut transaction)
-    .await?;
+    .await
+    .wrap_internal_err("failed to upsert Delphi report")?;
 
     info!(
         num_issues = %report.issues.len(),
@@ -292,8 +298,9 @@ async fn ingest_report_deserialized(
             report_id,
             issue_type: "__dummy".into(),
         }
-        .insert(&mut transaction)
-        .await?;
+        .upsert(&mut transaction)
+        .await
+        .wrap_internal_err("failed to upsert dummy Delphi report issue")?;
 
         ReportIssueDetail {
             id: DelphiReportIssueDetailsId(0), // This will be set by the database
@@ -307,7 +314,10 @@ async fn ingest_report_deserialized(
             status: DelphiStatus::Pending,
         }
         .insert(&mut transaction)
-        .await?;
+        .await
+        .wrap_internal_err(
+            "failed to insert dummy Delphi report issue detail",
+        )?;
     }
 
     for (issue_type, issue_details) in report.issues {
@@ -316,12 +326,14 @@ async fn ingest_report_deserialized(
             report_id,
             issue_type,
         }
-        .insert(&mut transaction)
-        .await?;
+        .upsert(&mut transaction)
+        .await
+        .wrap_internal_err("failed to upsert Delphi report issue")?;
 
         // This is required to handle the case where the same Delphi version is re-run on the same file
         ReportIssueDetail::remove_all_by_issue_id(issue_id, &mut transaction)
-            .await?;
+            .await
+            .wrap_internal_err("failed to remove old Delphi issue details")?;
 
         for issue_detail in issue_details {
             let decompiled_source =
@@ -339,11 +351,15 @@ async fn ingest_report_deserialized(
                 status: DelphiStatus::Pending,
             }
             .insert(&mut transaction)
-            .await?;
+            .await
+            .wrap_internal_err("failed to insert Delphi issue detail")?;
         }
     }
 
-    transaction.commit().await?;
+    transaction
+        .commit()
+        .await
+        .wrap_internal_err("failed to commit Delphi ingest transaction")?;
 
     Ok(())
 }