refactor(config): make ensure_installed async

Author: rami3l

src/bin/rustup-init.rs

@@ -140,7 +140,7 @@ async fn run_rustup_inner() -> Result<utils::ExitCode> {
         }
         Some(n) => {
             is_proxyable_tools(n)?;
-            proxy_mode::main(n).map(ExitCode::from)
+            proxy_mode::main(n).await.map(ExitCode::from)
         }
         None => {
             // Weird case. No arg0, or it's unparsable.

src/cli/proxy_mode.rs

@@ -13,7 +13,7 @@ use crate::{
 };
 
 #[cfg_attr(feature = "otel", tracing::instrument)]
-pub fn main(arg0: &str) -> Result<ExitStatus> {
+pub async fn main(arg0: &str) -> Result<ExitStatus> {
     self_update::cleanup_self_updater()?;
 
     let _setup = job::setup();
@@ -40,18 +40,21 @@ pub fn main(arg0: &str) -> Result<ExitStatus> {
     let toolchain = toolchain
         .map(|t| t.resolve(&cfg.get_default_host_triple()?))
         .transpose()?;
-    direct_proxy(&cfg, arg0, toolchain, &cmd_args)
+    direct_proxy(&cfg, arg0, toolchain, &cmd_args).await
 }
 
 #[cfg_attr(feature = "otel", tracing::instrument(skip(cfg)))]
-fn direct_proxy(
+async fn direct_proxy(
     cfg: &Cfg,
     arg0: &str,
     toolchain: Option<LocalToolchainName>,
     args: &[OsString],
 ) -> Result<ExitStatus> {
     let cmd = match toolchain {
-        None => cfg.create_command_for_dir(&utils::current_dir()?, arg0)?,
+        None => {
+            cfg.create_command_for_dir(&utils::current_dir()?, arg0)
+                .await?
+        }
         Some(tc) => cfg.create_command_for_toolchain(&tc, false, arg0)?,
     };
     run_command_for_dir(cmd, arg0, args)

src/cli/rustup_mode.rs

@@ -541,7 +541,7 @@ pub async fn main() -> Result<utils::ExitCode> {
             info!("This is the version for the rustup toolchain manager, not the rustc compiler.");
 
             #[cfg_attr(feature = "otel", tracing::instrument)]
-            fn rustc_version() -> std::result::Result<String, Box<dyn std::error::Error>> {
+            async fn rustc_version() -> std::result::Result<String, Box<dyn std::error::Error>> {
                 let cfg = &mut common::set_globals(false, true)?;
                 let cwd = std::env::current_dir()?;
 
@@ -550,12 +550,12 @@ pub async fn main() -> Result<utils::ExitCode> {
                     cfg.set_toolchain_override(&ResolvableToolchainName::try_from(&t[1..])?);
                 }
 
-                let toolchain = cfg.find_or_install_active_toolchain(&cwd)?.0;
+                let toolchain = cfg.find_or_install_active_toolchain(&cwd).await?.0;
 
                 Ok(toolchain.rustc_version())
             }
 
-            match rustc_version() {
+            match rustc_version().await {
                 Ok(version) => info!("The currently active `rustc` version is `{}`", version),
                 Err(err) => debug!("Wanted to tell you the current rustc version, too, but ran into this error: {}", err),
             }
@@ -640,7 +640,7 @@ pub async fn main() -> Result<utils::ExitCode> {
             TargetSubcmd::List {
                 toolchain,
                 installed,
-            } => handle_epipe(target_list(cfg, toolchain, installed)),
+            } => handle_epipe(target_list(cfg, toolchain, installed).await),
             TargetSubcmd::Add { target, toolchain } => target_add(cfg, target, toolchain).await,
             TargetSubcmd::Remove { target, toolchain } => {
                 target_remove(cfg, target, toolchain).await
@@ -650,7 +650,7 @@ pub async fn main() -> Result<utils::ExitCode> {
             ComponentSubcmd::List {
                 toolchain,
                 installed,
-            } => handle_epipe(component_list(cfg, toolchain, installed)),
+            } => handle_epipe(component_list(cfg, toolchain, installed).await),
             ComponentSubcmd::Add {
                 component,
                 toolchain,
@@ -676,15 +676,15 @@ pub async fn main() -> Result<utils::ExitCode> {
             command,
             install,
         } => run(cfg, toolchain, command, install).map(ExitCode::from),
-        RustupSubcmd::Which { command, toolchain } => which(cfg, &command, toolchain),
+        RustupSubcmd::Which { command, toolchain } => which(cfg, &command, toolchain).await,
         RustupSubcmd::Doc {
             path,
             toolchain,
             topic,
             page,
-        } => doc(cfg, path, toolchain, topic.as_deref(), &page),
+        } => doc(cfg, path, toolchain, topic.as_deref(), &page).await,
         #[cfg(not(windows))]
-        RustupSubcmd::Man { command, toolchain } => man(cfg, &command, toolchain),
+        RustupSubcmd::Man { command, toolchain } => man(cfg, &command, toolchain).await,
         RustupSubcmd::Self_ { subcmd } => match subcmd {
             SelfSubcmd::Update => self_update::update(cfg).await,
             SelfSubcmd::Uninstall { no_prompt } => self_update::uninstall(no_prompt),
@@ -904,7 +904,7 @@ fn run(
     command::run_command_for_dir(cmd, &command[0], &command[1..])
 }
 
-fn which(
+async fn which(
     cfg: &Cfg,
     binary: &str,
     toolchain: Option<ResolvableToolchainName>,
@@ -913,7 +913,7 @@ fn which(
         let desc = toolchain.resolve(&cfg.get_default_host_triple()?)?;
         Toolchain::new(cfg, desc.into())?.binary_file(binary)
     } else {
-        cfg.which_binary(&utils::current_dir()?, binary)?
+        cfg.which_binary(&utils::current_dir()?, binary).await?
     };
 
     utils::assert_is_file(&binary_path)?;
@@ -1091,13 +1091,13 @@ fn show_rustup_home(cfg: &Cfg) -> Result<utils::ExitCode> {
     Ok(utils::ExitCode(0))
 }
 
-fn target_list(
+async fn target_list(
     cfg: &Cfg,
     toolchain: Option<PartialToolchainDesc>,
     installed_only: bool,
 ) -> Result<utils::ExitCode> {
     // downcasting required because the toolchain files can name any toolchain
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     common::list_items(
         distributable,
         |c| {
@@ -1122,7 +1122,7 @@ async fn target_add(
     // isn't a feature yet.
     // list_components *and* add_component would both be inappropriate for
     // custom toolchains.
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     let components = distributable.components()?;
 
     if targets.contains(&"all".to_string()) {
@@ -1166,7 +1166,7 @@ async fn target_remove(
     targets: Vec<String>,
     toolchain: Option<PartialToolchainDesc>,
 ) -> Result<utils::ExitCode> {
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
 
     for target in targets {
         let target = TargetTriple::new(target);
@@ -1195,13 +1195,13 @@ async fn target_remove(
     Ok(utils::ExitCode(0))
 }
 
-fn component_list(
+async fn component_list(
     cfg: &Cfg,
     toolchain: Option<PartialToolchainDesc>,
     installed_only: bool,
 ) -> Result<utils::ExitCode> {
     // downcasting required because the toolchain files can name any toolchain
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     common::list_items(distributable, |c| Some(&c.name), installed_only)?;
     Ok(utils::ExitCode(0))
 }
@@ -1212,7 +1212,7 @@ async fn component_add(
     toolchain: Option<PartialToolchainDesc>,
     target: Option<String>,
 ) -> Result<utils::ExitCode> {
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     let target = get_target(target, &distributable);
 
     for component in &components {
@@ -1238,7 +1238,7 @@ async fn component_remove(
     toolchain: Option<PartialToolchainDesc>,
     target: Option<String>,
 ) -> Result<utils::ExitCode> {
-    let distributable = DistributableToolchain::from_partial(toolchain, cfg)?;
+    let distributable = DistributableToolchain::from_partial(toolchain, cfg).await?;
     let target = get_target(target, &distributable);
 
     for component in &components {
@@ -1418,14 +1418,14 @@ docs_data![
     (embedded_book, "The Embedded Rust Book", "embedded-book/index.html"),
 ];
 
-fn doc(
+async fn doc(
     cfg: &Cfg,
     path_only: bool,
     toolchain: Option<PartialToolchainDesc>,
     mut topic: Option<&str>,
     doc_page: &DocPage,
 ) -> Result<utils::ExitCode> {
-    let toolchain = Toolchain::from_partial(toolchain, cfg)?;
+    let toolchain = Toolchain::from_partial(toolchain, cfg).await?;
 
     if let Ok(distributable) = DistributableToolchain::try_from(&toolchain) {
         if let [_] = distributable
@@ -1481,14 +1481,14 @@ fn doc(
 }
 
 #[cfg(not(windows))]
-fn man(
+async fn man(
     cfg: &Cfg,
     command: &str,
     toolchain: Option<PartialToolchainDesc>,
 ) -> Result<utils::ExitCode> {
     use crate::currentprocess::varsource::VarSource;
 
-    let toolchain = Toolchain::from_partial(toolchain, cfg)?;
+    let toolchain = Toolchain::from_partial(toolchain, cfg).await?;
     let mut path = toolchain.path().to_path_buf();
     path.push("share");
     path.push("man");

src/config.rs

@@ -490,8 +490,8 @@ impl Cfg {
         Ok(self.update_hash_dir.join(toolchain.to_string()))
     }
 
-    pub(crate) fn which_binary(&self, path: &Path, binary: &str) -> Result<PathBuf> {
-        let (toolchain, _) = self.find_or_install_active_toolchain(path)?;
+    pub(crate) async fn which_binary(&self, path: &Path, binary: &str) -> Result<PathBuf> {
+        let (toolchain, _) = self.find_or_install_active_toolchain(path).await?;
         Ok(toolchain.binary_file(binary))
     }
 
@@ -726,16 +726,17 @@ impl Cfg {
         }
     }
 
-    pub(crate) fn find_or_install_active_toolchain(
+    pub(crate) async fn find_or_install_active_toolchain(
         &self,
         path: &Path,
     ) -> Result<(Toolchain<'_>, ActiveReason)> {
-        self.maybe_find_or_install_active_toolchain(path)?
+        self.maybe_find_or_install_active_toolchain(path)
+            .await?
             .ok_or(RustupError::ToolchainNotSelected.into())
     }
 
     #[cfg_attr(feature = "otel", tracing::instrument(skip_all))]
-    pub(crate) fn maybe_find_or_install_active_toolchain(
+    pub(crate) async fn maybe_find_or_install_active_toolchain(
         &self,
         path: &Path,
     ) -> Result<Option<(Toolchain<'_>, ActiveReason)>> {
@@ -756,8 +757,9 @@ impl Cfg {
                     targets,
                     profile,
                 } => {
-                    let toolchain =
-                        self.ensure_installed(toolchain, components, targets, profile)?;
+                    let toolchain = self
+                        .ensure_installed(toolchain, components, targets, profile)
+                        .await?;
                     Ok(Some((toolchain, reason)))
                 }
             },
@@ -770,7 +772,9 @@ impl Cfg {
                 }
                 Some(ToolchainName::Official(toolchain_desc)) => {
                     let reason = ActiveReason::Default;
-                    let toolchain = self.ensure_installed(toolchain_desc, vec![], vec![], None)?;
+                    let toolchain = self
+                        .ensure_installed(toolchain_desc, vec![], vec![], None)
+                        .await?;
                     Ok(Some((toolchain, reason)))
                 }
             },
@@ -779,7 +783,7 @@ impl Cfg {
 
     // Returns a Toolchain matching the given ToolchainDesc, installing it and
     // the given components and targets if they aren't already installed.
-    fn ensure_installed(
+    async fn ensure_installed(
         &self,
         toolchain: ToolchainDesc,
         components: Vec<String>,
@@ -790,14 +794,15 @@ impl Cfg {
         let targets: Vec<_> = targets.iter().map(AsRef::as_ref).collect();
         let toolchain = match DistributableToolchain::new(self, toolchain.clone()) {
             Err(RustupError::ToolchainNotInstalled(_)) => {
-                utils::run_future(DistributableToolchain::install(
+                DistributableToolchain::install(
                     self,
                     &toolchain,
                     &components,
                     &targets,
                     profile.unwrap_or(Profile::Default),
                     false,
-                ))?
+                )
+                .await?
                 .1
             }
             Ok(mut distributable) => {
@@ -932,8 +937,12 @@ impl Cfg {
         })
     }
 
-    pub(crate) fn create_command_for_dir(&self, path: &Path, binary: &str) -> Result<Command> {
-        let (toolchain, _) = self.find_or_install_active_toolchain(path)?;
+    pub(crate) async fn create_command_for_dir(
+        &self,
+        path: &Path,
+        binary: &str,
+    ) -> Result<Command> {
+        let (toolchain, _) = self.find_or_install_active_toolchain(path).await?;
         self.create_command_for_toolchain_(toolchain, binary)
     }
 

src/toolchain/distributable.rs

@@ -33,11 +33,13 @@ pub(crate) struct DistributableToolchain<'a> {
 }
 
 impl<'a> DistributableToolchain<'a> {
-    pub(crate) fn from_partial(
+    pub(crate) async fn from_partial(
         toolchain: Option<PartialToolchainDesc>,
         cfg: &'a Cfg,
     ) -> anyhow::Result<Self> {
-        Ok(Self::try_from(&Toolchain::from_partial(toolchain, cfg)?)?)
+        Ok(Self::try_from(
+            &Toolchain::from_partial(toolchain, cfg).await?,
+        )?)
     }
 
     pub(crate) fn new(cfg: &'a Cfg, desc: ToolchainDesc) -> Result<Self, RustupError> {

src/toolchain/toolchain.rs

@@ -37,7 +37,7 @@ pub(crate) struct Toolchain<'a> {
 }
 
 impl<'a> Toolchain<'a> {
-    pub(crate) fn from_partial(
+    pub(crate) async fn from_partial(
         toolchain: Option<PartialToolchainDesc>,
         cfg: &'a Cfg,
     ) -> anyhow::Result<Self> {
@@ -48,7 +48,7 @@ impl<'a> Toolchain<'a> {
             }
             None => {
                 let cwd = utils::current_dir()?;
-                let (toolchain, _) = cfg.find_or_install_active_toolchain(&cwd)?;
+                let (toolchain, _) = cfg.find_or_install_active_toolchain(&cwd).await?;
 
                 Ok(toolchain)
             }