consistency: warn & continue when errors happen while fixing inconsistencies

Author: syphar

Cargo.toml

@@ -97,6 +97,7 @@ percent-encoding = "2.2.0"
 
 # NOTE: if you change this, also double-check that the comment in `queue_builder::remove_tempdirs` is still accurate.
 tempfile = "3.1.0"
+fn-error-context = "0.2.0"
 
 # Templating
 tera = { version = "1.5.0", features = ["builtins"] }
@@ -122,7 +123,6 @@ kuchiki = "0.8"
 rand = "0.8"
 mockito = "0.31.0"
 test-case = "2.0.0"
-fn-error-context = "0.2.0"
 aws-smithy-client = { version = "0.52.0", features = ["test-util"]}
 aws-smithy-http = "0.52.0"
 indoc = "1.0.7"

src/build_queue.rs

@@ -6,6 +6,7 @@ use crate::storage::Storage;
 use crate::utils::{get_config, get_crate_priority, report_error, set_config, ConfigName};
 use crate::{Config, Index, Metrics, RustwideBuilder};
 use anyhow::Context;
+use fn_error_context::context;
 
 use tracing::{debug, error, info, instrument, warn};
 
@@ -72,6 +73,7 @@ impl BuildQueue {
         Ok(())
     }
 
+    #[context("error trying to add {name}-{version} to build queue")]
     pub fn add_crate(
         &self,
         name: &str,
@@ -266,22 +268,25 @@ fn retry<T>(mut f: impl FnMut() -> Result<T>, max_attempts: u32) -> Result<T> {
 }
 
 #[instrument(skip(conn))]
-pub fn set_yanked(conn: &mut postgres::Client, name: &str, version: &str, yanked: bool) {
+#[context("error trying to set {name}-{version} to yanked: {yanked}")]
+pub fn set_yanked(
+    conn: &mut postgres::Client,
+    name: &str,
+    version: &str,
+    yanked: bool,
+) -> Result<()> {
     let activity = if yanked { "yanked" } else { "unyanked" };
 
-    match conn
-        .execute(
-            "UPDATE releases
+    match conn.execute(
+        "UPDATE releases
                  SET yanked = $3
              FROM crates
              WHERE crates.id = releases.crate_id
                  AND name = $1
                  AND version = $2
             ",
-            &[&name, &version, &yanked],
-        )
-        .with_context(|| format!("error while setting {}-{} to {}", name, version, activity))
-    {
+        &[&name, &version, &yanked],
+    ) {
         Ok(rows) => {
             if rows != 1 {
                 error!(
@@ -290,9 +295,10 @@ pub fn set_yanked(conn: &mut postgres::Client, name: &str, version: &str, yanked
                 );
             } else {
                 debug!("{}-{} {}", name, version, activity);
-            }
+            };
+            Ok(())
         }
-        Err(err) => report_error(&err),
+        Err(err) => Err(err.into()),
     }
 }
 
@@ -359,12 +365,14 @@ impl BuildQueue {
             if let Some(release) = yanked.or(unyanked) {
                 // FIXME: delay yanks of crates that have not yet finished building
                 // https://github.com/rust-lang/docs.rs/issues/1934
-                set_yanked(
+                if let Err(err) = set_yanked(
                     &mut conn,
                     release.name.as_str(),
                     release.version.as_str(),
                     yanked.is_some(),
-                );
+                ) {
+                    report_error(&err);
+                }
 
                 if let Err(err) = cdn::invalidate_crate(&self.config, &self.cdn, &release.name) {
                     report_error(&err);

src/db/delete.rs

@@ -2,6 +2,7 @@ use crate::error::Result;
 use crate::storage::{rustdoc_archive_path, source_archive_path, Storage};
 use crate::{Config, Context};
 use anyhow::Context as _;
+use fn_error_context::context;
 use postgres::Client;
 use std::fs;
 
@@ -16,6 +17,7 @@ enum CrateDeletionError {
     MissingCrate(String),
 }
 
+#[context("error trying to delete crate {name} from database")]
 pub fn delete_crate(
     conn: &mut Client,
     storage: &Storage,
@@ -52,6 +54,7 @@ pub fn delete_crate(
     Ok(())
 }
 
+#[context("error trying to delete release {name}-{version} from database")]
 pub fn delete_version(ctx: &dyn Context, name: &str, version: &str) -> Result<()> {
     let conn = &mut ctx.pool()?.get()?;
     let storage = ctx.storage()?;

src/utils/consistency/mod.rs

@@ -1,7 +1,7 @@
 use crate::{build_queue, db::delete, Context};
 use anyhow::{Context as _, Result};
 use itertools::Itertools;
-use tracing::info;
+use tracing::{info, warn};
 
 mod data;
 mod db;
@@ -92,33 +92,44 @@ where
         match difference {
             diff::Difference::CrateNotInIndex(name) => {
                 if !dry_run {
-                    delete::delete_crate(&mut conn, &storage, &config, name)?;
+                    if let Err(err) = delete::delete_crate(&mut conn, &storage, &config, name) {
+                        warn!("{:?}", err);
+                    }
                 }
                 result.crates_deleted += 1;
             }
             diff::Difference::CrateNotInDb(name, versions) => {
                 for version in versions {
                     if !dry_run {
-                        build_queue.add_crate(name, version, BUILD_PRIORITY, None)?;
+                        if let Err(err) = build_queue.add_crate(name, version, BUILD_PRIORITY, None)
+                        {
+                            warn!("{:?}", err);
+                        }
                     }
                     result.builds_queued += 1;
                 }
             }
             diff::Difference::ReleaseNotInIndex(name, version) => {
                 if !dry_run {
-                    delete::delete_version(ctx, name, version)?;
+                    if let Err(err) = delete::delete_version(ctx, name, version) {
+                        warn!("{:?}", err);
+                    }
                 }
                 result.releases_deleted += 1;
             }
             diff::Difference::ReleaseNotInDb(name, version) => {
                 if !dry_run {
-                    build_queue.add_crate(name, version, BUILD_PRIORITY, None)?;
+                    if let Err(err) = build_queue.add_crate(name, version, BUILD_PRIORITY, None) {
+                        warn!("{:?}", err);
+                    }
                 }
                 result.builds_queued += 1;
             }
             diff::Difference::ReleaseYank(name, version, yanked) => {
                 if !dry_run {
-                    build_queue::set_yanked(&mut conn, name, version, *yanked);
+                    if let Err(err) = build_queue::set_yanked(&mut conn, name, version, *yanked) {
+                        warn!("{:?}", err);
+                    }
                 }
                 result.yanks_corrected += 1;
             }