From 784c521c48df7048e7db7a612adee366e23faf4d Mon Sep 17 00:00:00 2001
From: Denis Cornehl <denis@cornehl.org>
Date: Sat, 13 Jul 2024 07:12:10 +0200
Subject: [PATCH] also queue rebuilds for broken db indexes

---
 src/bin/cratesfyi.rs | 37 ++++++++++++++++++++++++++++---------
 src/build_queue.rs   |  2 +-
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/src/bin/cratesfyi.rs b/src/bin/cratesfyi.rs
index 95f1caf05..d8b5d6407 100644
--- a/src/bin/cratesfyi.rs
+++ b/src/bin/cratesfyi.rs
@@ -577,6 +577,23 @@ impl DatabaseSubcommand {
                 let build_queue = ctx.build_queue()?;
                 ctx.runtime()?
                     .block_on(async {
+                        async fn queue_rebuild(
+                            build_queue: Arc<BuildQueue>,
+                            name: &str,
+                            version: &str,
+                        ) -> Result<()> {
+                            spawn_blocking({
+                                let name = name.to_owned();
+                                let version = version.to_owned();
+                                move || {
+                                    if !build_queue.has_build_queued(&name, &version)? {
+                                        build_queue.add_crate(&name, &version, 5, None)?;
+                                    }
+                                    Ok(())
+                                }
+                            })
+                            .await
+                        }
                         let storage = ctx.async_storage().await?;
                         let mut conn = pool.get_async().await?;
                         let mut result_stream = sqlx::query!(
@@ -615,11 +632,18 @@ impl DatabaseSubcommand {
                                 };
 
                                 let count = {
-                                    let connection = Connection::open_with_flags(
+                                    let connection = match Connection::open_with_flags(
                                         &local_archive_index_filename,
                                         OpenFlags::SQLITE_OPEN_READ_ONLY
                                             | OpenFlags::SQLITE_OPEN_NO_MUTEX,
-                                    )?;
+                                    ) {
+                                        Ok(conn) => conn,
+                                        Err(err) => {
+                                            println!("... error opening sqlite db, queueing rebuild: {:?}", err);
+                                            queue_rebuild(build_queue.clone(), &row.name, &row.version).await?;
+                                            continue;
+                                        }
+                                    };
                                     let mut stmt =
                                         connection.prepare("SELECT count(*) FROM files")?;
 
@@ -630,13 +654,8 @@ impl DatabaseSubcommand {
 
                                 if count >= 65000 {
                                     println!("...big index, queueing rebuild");
-                                    spawn_blocking({
-                                        let build_queue = build_queue.clone();
-                                        let name = row.name.clone();
-                                        let version = row.version.clone();
-                                        move || build_queue.add_crate(&name, &version, 5, None)
-                                    })
-                                    .await?;
+                                    queue_rebuild(build_queue.clone(), &row.name, &row.version)
+                                        .await?;
                                 }
                             }
                         }
diff --git a/src/build_queue.rs b/src/build_queue.rs
index 506acee9b..23068ac00 100644
--- a/src/build_queue.rs
+++ b/src/build_queue.rs
@@ -151,7 +151,7 @@ impl BuildQueue {
             .collect())
     }
 
-    pub(crate) fn has_build_queued(&self, name: &str, version: &str) -> Result<bool> {
+    pub fn has_build_queued(&self, name: &str, version: &str) -> Result<bool> {
         Ok(self
             .db
             .get()?