Separate updating toolchain from adding essential files so they can have different retries

Author: Nemo157

src/bin/cratesfyi.rs

@@ -442,6 +442,14 @@ impl BuildSubcommand {
                 rustwide_builder()?
                     .update_toolchain()
                     .context("failed to update toolchain")?;
+
+                rustwide_builder()?
+                    .purge_caches()
+                    .context("failed to purge caches")?;
+
+                rustwide_builder()?
+                    .add_essential_files()
+                    .context("failed to add essential files")?;
             }
 
             Self::AddEssentialFiles => {

src/build_queue.rs

@@ -440,6 +440,35 @@ impl BuildQueue {
         Ok(())
     }
 
+    fn update_toolchain(&self, builder: &mut RustwideBuilder) -> Result<()> {
+        let updated = retry(
+            || {
+                builder
+                    .update_toolchain()
+                    .context("downloading new toolchain failed")
+            },
+            3,
+        )?;
+
+        if updated {
+            // toolchain has changed, purge caches
+            retry(
+                || {
+                    builder
+                        .purge_caches()
+                        .context("purging rustwide caches failed")
+                },
+                3,
+            )?;
+
+            builder
+                .add_essential_files()
+                .context("adding essential files failed")?;
+        }
+
+        Ok(())
+    }
+
     /// Builds the top package from the queue. Returns whether there was a package in the queue.
     ///
     /// Note that this will return `Ok(true)` even if the package failed to build.
@@ -471,35 +500,13 @@ impl BuildQueue {
                 return Err(err);
             }
 
-            match retry(
-                || {
-                    builder
-                        .update_toolchain()
-                        .context("Updating toolchain failed, locking queue")
-                },
-                3,
-            ) {
-                Err(err) => {
-                    report_error(&err);
-                    self.lock()?;
-                    return Err(err);
-                }
-                Ok(true) => {
-                    // toolchain has changed, purge caches
-                    if let Err(err) = retry(
-                        || {
-                            builder
-                                .purge_caches()
-                                .context("purging rustwide caches failed, locking queue")
-                        },
-                        3,
-                    ) {
-                        report_error(&err);
-                        self.lock()?;
-                        return Err(err);
-                    }
-                }
-                Ok(false) => {}
+            if let Err(err) = self
+                .update_toolchain(&mut *builder)
+                .context("Updating toolchain failed, locking queue")
+            {
+                report_error(&err);
+                self.lock()?;
+                return Err(err);
             }
 
             builder.build_package(&krate.name, &krate.version, kind)?;

src/docbuilder/rustwide_builder.rs

@@ -222,9 +222,6 @@ impl RustwideBuilder {
         self.rustc_version = self.detect_rustc_version()?;
 
         let has_changed = old_version.as_deref() != Some(&self.rustc_version);
-        if has_changed {
-            self.add_essential_files()?;
-        }
         Ok(has_changed)
     }
 
@@ -331,7 +328,6 @@ impl RustwideBuilder {
     }
 
     pub fn build_local_package(&mut self, path: &Path) -> Result<bool> {
-        self.update_toolchain()?;
         let metadata = CargoMetadata::load_from_rustwide(&self.workspace, &self.toolchain, path)
             .map_err(|err| {
                 err.context(format!("failed to load local package {}", path.display()))
@@ -348,8 +344,6 @@ impl RustwideBuilder {
     ) -> Result<bool> {
         let mut conn = self.db.get()?;
 
-        self.update_toolchain()?;
-
         info!("building package {} {}", name, version);
 
         if is_blacklisted(&mut conn, name)? {