dist: install updates directly via DistOptions

Author: djc

src/cli/common.rs

@@ -16,9 +16,9 @@ use tracing_subscriber::{EnvFilter, Registry, reload::Handle};
 
 use crate::{
     config::Cfg,
-    dist::{TargetTriple, ToolchainDesc},
+    dist::{DistOptions, TargetTriple, ToolchainDesc},
     errors::RustupError,
-    install::UpdateStatus,
+    install::{InstallMethod, UpdateStatus},
     process::Process,
     toolchain::{LocalToolchainName, Toolchain, ToolchainName},
     utils,
@@ -217,10 +217,10 @@ pub(crate) async fn update_all_channels(
 ) -> Result<utils::ExitCode> {
     let profile = cfg.get_profile()?;
     let mut toolchains = Vec::new();
-    for (desc, mut distributable) in cfg.list_channels()? {
-        let result = distributable
-            .update(&[], &[], profile, force_update, false)
-            .await;
+    for (desc, distributable) in cfg.list_channels()? {
+        let options = DistOptions::new(&[], &[], &desc, Some(profile), force_update, cfg)?
+            .for_update(&distributable, false);
+        let result = InstallMethod::Dist(options).install().await;
 
         if let Err(e) = &result {
             error!("{e}");

src/cli/rustup_mode.rs

@@ -960,18 +960,15 @@ async fn update(
 
             let components = opts.component.iter().map(|s| &**s).collect::<Vec<_>>();
             let targets = opts.target.iter().map(|s| &**s).collect::<Vec<_>>();
+            let dist_opts = DistOptions::new(&components, &targets, &desc, None, opts.force, cfg)?;
 
-            let force = opts.force;
-            let allow_downgrade = opts.allow_downgrade;
             let status = match DistributableToolchain::new(cfg, desc.clone()) {
-                Ok(mut d) => {
-                    let profile = cfg.get_profile()?;
-                    d.update(&components, &targets, profile, force, allow_downgrade)
+                Ok(d) => {
+                    InstallMethod::Dist(dist_opts.for_update(&d, opts.allow_downgrade))
+                        .install()
                         .await?
                 }
                 Err(RustupError::ToolchainNotInstalled { .. }) => {
-                    let dist_opts =
-                        DistOptions::new(&components, &targets, &desc, None, force, cfg)?;
                     DistributableToolchain::install(dist_opts).await?.0
                 }
                 Err(e) => Err(e)?,

src/cli/self_update.rs

@@ -52,6 +52,7 @@ use serde::{Deserialize, Serialize};
 use tracing::{error, info, trace, warn};
 
 use crate::dist::DistOptions;
+use crate::install::InstallMethod;
 use crate::{
     DUP_TOOLS, TOOLS,
     cli::{
@@ -997,16 +998,17 @@ async fn maybe_install_rust(opts: InstallOpts<'_>, cfg: &mut Cfg<'_>) -> Result<
     let (components, targets) = (opts.components, opts.targets);
     let toolchain = opts.install(cfg)?;
     if let Some(desc) = &toolchain {
+        let options = DistOptions::new(components, targets, desc, None, true, cfg)?;
         let status = if Toolchain::exists(cfg, &desc.into())? {
             warn!("Updating existing toolchain, profile choice will be ignored");
             // If we have a partial install we might not be able to read content here. We could:
             // - fail and folk have to delete the partially present toolchain to recover
             // - silently ignore it (and provide inconsistent metadata for reporting the install/update change)
             // - delete the partial install and start over
             // For now, we error.
-            let mut toolchain = DistributableToolchain::new(cfg, desc.clone())?;
-            toolchain
-                .update(components, targets, cfg.get_profile()?, true, false)
+            let toolchain = DistributableToolchain::new(cfg, desc.clone())?;
+            InstallMethod::Dist(options.for_update(&toolchain, true))
+                .install()
                 .await?
         } else {
             let options = DistOptions::new(components, targets, desc, None, true, cfg)?;

src/config.rs

@@ -9,6 +9,7 @@ use thiserror::Error as ThisError;
 use tracing::{debug, error, info, trace, warn};
 
 use crate::dist::{AutoInstallMode, DistOptions};
+use crate::install::InstallMethod;
 use crate::{
     cli::{common, self_update::SelfUpdateMode},
     dist::{self, PartialToolchainDesc, Profile, TargetTriple, ToolchainDesc, temp},
@@ -787,25 +788,19 @@ impl<'a> Cfg<'a> {
         }
         let components: Vec<_> = components.iter().map(AsRef::as_ref).collect();
         let targets: Vec<_> = targets.iter().map(AsRef::as_ref).collect();
+        let options = DistOptions::new(&components, &targets, toolchain, profile, false, self)?;
 
         let (status, toolchain) = match DistributableToolchain::new(self, toolchain.clone()) {
             Err(RustupError::ToolchainNotInstalled { .. }) => {
-                let options =
-                    DistOptions::new(&components, &targets, toolchain, profile, false, self)?;
                 DistributableToolchain::install(options).await?
             }
-            Ok(mut distributable) => {
+            Ok(distributable) => {
                 if verbose {
                     info!("using existing install for {toolchain}");
                 }
                 let status = if !distributable.components_exist(&components, &targets)? {
-                    let profile = match profile {
-                        Some(profile) => profile,
-                        None => self.get_profile()?,
-                    };
-
-                    distributable
-                        .update(&components, &targets, profile, true, false)
+                    InstallMethod::Dist(options.for_update(&distributable, false))
+                        .install()
                         .await?
                 } else {
                     UpdateStatus::Unchanged

src/dist/mod.rs

@@ -19,7 +19,13 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error as ThisError;
 use tracing::{debug, info, warn};
 
-use crate::{config::Cfg, errors::RustupError, process::Process, toolchain::ToolchainName, utils};
+use crate::{
+    config::Cfg,
+    errors::RustupError,
+    process::Process,
+    toolchain::{DistributableToolchain, ToolchainName},
+    utils,
+};
 
 pub mod component;
 pub(crate) mod config;
@@ -922,6 +928,31 @@ impl<'cfg, 'a> DistOptions<'cfg, 'a> {
             targets,
         })
     }
+
+    pub(super) fn for_update(
+        mut self,
+        toolchain: &'a DistributableToolchain<'cfg>,
+        allow_downgrade: bool,
+    ) -> Self {
+        self.allow_downgrade = allow_downgrade;
+        self.exists = true;
+        self.old_date_version =
+            // Ignore a missing manifest: we can't report the old version
+            // correctly, and it probably indicates an incomplete install, so do
+            // not report an old rustc version either.
+            toolchain.get_manifest()
+                .map(|m| {
+                    (
+                        m.date,
+                        // should rustc_version be a free function on a trait?
+                        // note that prev_version can be junk if the rustc component is missing ...
+                        toolchain.toolchain.rustc_version(),
+                    )
+                })
+                .ok();
+
+        self
+    }
 }
 
 // Installs or updates a toolchain from a dist server. If an initial

src/toolchain/distributable.rs

@@ -11,7 +11,7 @@ use crate::{
     RustupError, component_for_bin,
     config::{ActiveSource, Cfg},
     dist::{
-        DistOptions, PartialToolchainDesc, Profile, ToolchainDesc,
+        DistOptions, PartialToolchainDesc, ToolchainDesc,
         config::Config,
         download::DownloadCfg,
         manifest::{Component, ComponentStatus, Manifest},
@@ -29,7 +29,7 @@ use super::{
 /// An official toolchain installed on the local disk
 #[derive(Debug)]
 pub(crate) struct DistributableToolchain<'a> {
-    pub(super) toolchain: Toolchain<'a>,
+    pub(crate) toolchain: Toolchain<'a>,
     desc: ToolchainDesc,
 }
 
@@ -345,45 +345,6 @@ impl<'a> DistributableToolchain<'a> {
         InstallPrefix::from(self.toolchain.path().to_owned()).guess_v1_manifest()
     }
 
-    /// Update a toolchain with control over the channel behaviour
-    #[tracing::instrument(level = "trace", err(level = "trace"), skip_all)]
-    pub(crate) async fn update(
-        &mut self,
-        components: &[&str],
-        targets: &[&str],
-        profile: Profile,
-        force: bool,
-        allow_downgrade: bool,
-    ) -> anyhow::Result<UpdateStatus> {
-        let mut options = DistOptions::new(
-            components,
-            targets,
-            &self.desc,
-            Some(profile),
-            force,
-            self.toolchain.cfg,
-        )?;
-
-        options.allow_downgrade = allow_downgrade;
-        options.exists = true;
-        options.old_date_version =
-            // Ignore a missing manifest: we can't report the old version
-            // correctly, and it probably indicates an incomplete install, so do
-            // not report an old rustc version either.
-            self.get_manifest()
-                .map(|m| {
-                    (
-                        m.date,
-                        // should rustc_version be a free function on a trait?
-                        // note that prev_version can be junk if the rustc component is missing ...
-                        self.toolchain.rustc_version(),
-                    )
-                })
-                .ok();
-
-        InstallMethod::Dist(options).install().await
-    }
-
     pub fn recursion_error(&self, binary_lossy: String) -> Result<Infallible, anyhow::Error> {
         let prefix = InstallPrefix::from(self.toolchain.path());
         let manifestation = Manifestation::open(prefix, self.desc.target.clone())?;