Skip running a job if the crate/version deleted

src/tests/worker/mod.rs

@@ -1,3 +1,6 @@
 mod git;
+mod readmes;
 mod rss;
+mod send_publish_notifications;
 mod sync_admins;
+mod update_default_version;

src/tests/worker/readmes.rs

@@ -0,0 +1,17 @@
+use crate::tests::util::TestApp;
+use crate::worker::jobs;
+use crates_io_worker::BackgroundJob;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn skips_when_crate_deleted() -> anyhow::Result<()> {
+    let (app, _) = TestApp::full().empty().await;
+    let mut conn = app.db_conn().await;
+
+    let job =
+        jobs::RenderAndUploadReadme::new(-1, "deleted".to_string(), ".".to_string(), None, None);
+
+    job.enqueue(&mut conn).await?;
+    app.run_pending_background_jobs().await;
+
+    Ok(())
+}

src/tests/worker/send_publish_notifications.rs

@@ -0,0 +1,16 @@
+use crate::tests::util::TestApp;
+use crate::worker::jobs;
+use crates_io_worker::BackgroundJob;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn skips_when_crate_deleted() -> anyhow::Result<()> {
+    let (app, _) = TestApp::full().empty().await;
+    let mut conn = app.db_conn().await;
+
+    let job = jobs::SendPublishNotificationsJob::new(-1);
+
+    job.enqueue(&mut conn).await?;
+    app.run_pending_background_jobs().await;
+
+    Ok(())
+}

src/tests/worker/update_default_version.rs

@@ -0,0 +1,16 @@
+use crate::tests::util::TestApp;
+use crate::worker::jobs;
+use crates_io_worker::BackgroundJob;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn skips_when_crate_deleted() -> anyhow::Result<()> {
+    let (app, _) = TestApp::full().empty().await;
+    let mut conn = app.db_conn().await;
+
+    let job = jobs::UpdateDefaultVersion::new(-1);
+
+    job.enqueue(&mut conn).await?;
+    app.run_pending_background_jobs().await;
+
+    Ok(())
+}

src/worker/jobs/readmes.rs

@@ -9,7 +9,7 @@ use diesel_async::AsyncConnection;
 use diesel_async::scoped_futures::ScopedFutureExt;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
-use tracing::{info, instrument};
+use tracing::{info, instrument, warn};
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct RenderAndUploadReadme {
@@ -70,13 +70,31 @@ impl BackgroundJob for RenderAndUploadReadme {
         let mut conn = env.deadpool.get().await?;
         conn.transaction(|conn| {
             async move {
-                Version::record_readme_rendering(job.version_id, conn).await?;
-                let (crate_name, vers): (String, String) = versions::table
-                    .find(job.version_id)
-                    .inner_join(crates::table)
-                    .select((crates::name, versions::num))
-                    .first(conn)
-                    .await?;
+                let (crate_name, vers): (String, String) =
+                    match Version::record_readme_rendering(job.version_id, conn)
+                        .await
+                        .and(
+                            versions::table
+                                .find(job.version_id)
+                                .inner_join(crates::table)
+                                .select((crates::name, versions::num))
+                                .first(conn)
+                                .await,
+                        ) {
+                        Ok(r) => r,
+                        Err(diesel::result::Error::DatabaseError(
+                            diesel::result::DatabaseErrorKind::ForeignKeyViolation,
+                            ..,
+                        ))
+                        | Err(diesel::result::Error::NotFound) => {
+                            warn!(
+                                "Skipping rendering README for version {}: no version found",
+                                job.version_id
+                            );
+                            return Ok(());
+                        }
+                        Err(err) => return Err(err.into()),
+                    };
 
                 tracing::Span::current().record("krate.name", tracing::field::display(&crate_name));
 

src/worker/jobs/send_publish_notifications.rs

@@ -39,7 +39,12 @@ impl BackgroundJob for SendPublishNotificationsJob {
         let mut conn = ctx.deadpool.get().await?;
 
         // Get crate name, version and other publish details
-        let publish_details = PublishDetails::for_version(version_id, &mut conn).await?;
+        let Some(publish_details) = PublishDetails::for_version(version_id, &mut conn).await?
+        else {
+            warn!("Skipping publish notifications for {version_id}: no version found");
+
+            return Ok(());
+        };
 
         let publish_time = publish_details
             .publish_time
@@ -157,13 +162,17 @@ struct PublishDetails {
 }
 
 impl PublishDetails {
-    async fn for_version(version_id: i32, conn: &mut AsyncPgConnection) -> QueryResult<Self> {
+    async fn for_version(
+        version_id: i32,
+        conn: &mut AsyncPgConnection,
+    ) -> QueryResult<Option<Self>> {
         versions::table
             .find(version_id)
             .inner_join(crates::table)
             .left_join(users::table)
             .select(PublishDetails::as_select())
             .first(conn)
             .await
+            .optional()
     }
 }

src/worker/jobs/update_default_version.rs

@@ -7,7 +7,7 @@ use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
-use tracing::info;
+use tracing::{info, warn};
 
 #[derive(Serialize, Deserialize)]
 pub struct UpdateDefaultVersion {
@@ -32,16 +32,25 @@ impl BackgroundJob for UpdateDefaultVersion {
 
         info!("Updating default version for crate {crate_id}");
         let mut conn = ctx.deadpool.get().await?;
-        update_default_version(crate_id, &mut conn).await?;
-
-        // Get the crate name for OG image generation
-        let crate_name: String = crates::table
-            .filter(crates::id.eq(crate_id))
-            .select(crates::name)
-            .first(&mut conn)
-            .await?;
+        let crate_name = update_default_version(crate_id, &mut conn).await.and(
+            // Get the crate name for OG image generation
+            crates::table
+                .filter(crates::id.eq(crate_id))
+                .select(crates::name)
+                .first::<String>(&mut conn)
+                .await,
+        );
+        if let Err(diesel::result::Error::DatabaseError(
+            diesel::result::DatabaseErrorKind::ForeignKeyViolation,
+            ..,
+        )) = crate_name
+        {
+            warn!("Skipping update default version for crate for {crate_id}: no crate found");
+            return Ok(());
+        }
 
         // Generate OG image after updating default version
+        let crate_name = crate_name?;
         info!("Enqueueing OG image generation for crate {crate_name}");
         GenerateOgImage::new(crate_name).enqueue(&mut conn).await?;