Make InstallMethod::install async

Author: rbtcollins

src/cli/rustup_mode.rs

@@ -1250,14 +1250,16 @@ fn toolchain_link(cfg: &Cfg, dest: &CustomToolchainName, src: &Path) -> Result<u
     utils::assert_is_file(&pathbuf)?;
 
     if true {
-        InstallMethod::Link {
-            src: &utils::to_absolute(src)?,
-            dest,
-            cfg,
-        }
-        .install()?;
+        utils::run_future(
+            InstallMethod::Link {
+                src: &utils::to_absolute(src)?,
+                dest,
+                cfg,
+            }
+            .install(),
+        )?;
     } else {
-        InstallMethod::Copy { src, dest, cfg }.install()?;
+        utils::run_future(InstallMethod::Copy { src, dest, cfg }.install())?;
     }
 
     Ok(utils::ExitCode(0))

src/install.rs

@@ -59,7 +59,7 @@ pub(crate) enum InstallMethod<'a> {
 impl<'a> InstallMethod<'a> {
     // Install a toolchain
     #[cfg_attr(feature = "otel", tracing::instrument(err, skip_all))]
-    pub(crate) fn install(&self) -> Result<UpdateStatus> {
+    pub(crate) async fn install(&self) -> Result<UpdateStatus> {
         let nh = self.cfg().notify_handler.clone();
         match self {
             InstallMethod::Copy { .. }
@@ -72,9 +72,11 @@ impl<'a> InstallMethod<'a> {
         }
 
         (self.cfg().notify_handler)(RootNotification::ToolchainDirectory(&self.dest_path()));
-        let updated = utils::run_future(self.run(&self.dest_path(), &|n| {
-            (self.cfg().notify_handler)(n.into())
-        }))?;
+        let updated = self
+            .run(&self.dest_path(), &|n| {
+                (self.cfg().notify_handler)(n.into())
+            })
+            .await?;
 
         let status = match updated {
             false => {

src/toolchain/distributable.rs

@@ -338,20 +338,22 @@ impl<'a> DistributableToolchain<'a> {
         let hash_path = cfg.get_hash_file(desc, true)?;
         let update_hash = Some(&hash_path as &Path);
 
-        let status = InstallMethod::Dist {
-            cfg,
-            desc,
-            profile,
-            update_hash,
-            dl_cfg: cfg.download_cfg(&|n| (cfg.notify_handler)(n.into())),
-            force,
-            allow_downgrade: false,
-            exists: false,
-            old_date_version: None,
-            components,
-            targets,
-        }
-        .install()?;
+        let status = utils::run_future(
+            InstallMethod::Dist {
+                cfg,
+                desc,
+                profile,
+                update_hash,
+                dl_cfg: cfg.download_cfg(&|n| (cfg.notify_handler)(n.into())),
+                force,
+                allow_downgrade: false,
+                exists: false,
+                old_date_version: None,
+                components,
+                targets,
+            }
+            .install(),
+        )?;
         Ok((status, Self::new(cfg, desc.clone())?))
     }
 
@@ -407,22 +409,24 @@ impl<'a> DistributableToolchain<'a> {
         let hash_path = self.cfg.get_hash_file(&self.desc, true)?;
         let update_hash = Some(&hash_path as &Path);
 
-        InstallMethod::Dist {
-            cfg: self.cfg,
-            desc: &self.desc,
-            profile,
-            update_hash,
-            dl_cfg: self
-                .cfg
-                .download_cfg(&|n| (self.cfg.notify_handler)(n.into())),
-            force,
-            allow_downgrade,
-            exists: true,
-            old_date_version,
-            components,
-            targets,
-        }
-        .install()
+        utils::run_future(
+            InstallMethod::Dist {
+                cfg: self.cfg,
+                desc: &self.desc,
+                profile,
+                update_hash,
+                dl_cfg: self
+                    .cfg
+                    .download_cfg(&|n| (self.cfg.notify_handler)(n.into())),
+                force,
+                allow_downgrade,
+                exists: true,
+                old_date_version,
+                components,
+                targets,
+            }
+            .install(),
+        )
     }
 
     pub fn recursion_error(&self, binary_lossy: String) -> Result<Infallible, anyhow::Error> {