dist: move Notifier into DownloadCfg

Author: djc

src/cli/common.rs

@@ -4,7 +4,7 @@ use std::fmt::Display;
 use std::fs;
 use std::io::{BufRead, Write};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, LazyLock};
+use std::sync::LazyLock;
 use std::{cmp, env};
 
 use anyhow::{Context, Result, anyhow};
@@ -13,7 +13,6 @@ use termcolor::Color;
 use tracing::{error, info, warn};
 use tracing_subscriber::{EnvFilter, Registry, reload::Handle};
 
-use crate::dist::download::Notifier;
 use crate::{
     config::Cfg,
     dist::{TargetTriple, ToolchainDesc},
@@ -122,8 +121,7 @@ pub(crate) fn read_line(process: &Process) -> Result<String> {
 
 #[tracing::instrument(level = "trace", skip(process))]
 pub(crate) fn set_globals(current_dir: PathBuf, quiet: bool, process: &Process) -> Result<Cfg<'_>> {
-    let notifier = Notifier::new(quiet, process);
-    Cfg::from_env(current_dir, Arc::new(move |n| notifier.handle(n)), process)
+    Cfg::from_env(current_dir, quiet, process)
 }
 
 pub(crate) fn show_channel_update(

src/cli/rustup_mode.rs

@@ -34,6 +34,7 @@ use crate::{
     config::{ActiveReason, Cfg},
     dist::{
         AutoInstallMode, PartialToolchainDesc, Profile, TargetTriple,
+        download::DownloadCfg,
         manifest::{Component, ComponentStatus},
     },
     errors::RustupError,
@@ -909,7 +910,7 @@ async fn check_updates(cfg: &Cfg<'_>, opts: CheckOpts) -> Result<utils::ExitCode
         && self_update_mode == SelfUpdateMode::Enable
         && !opts.no_self_update;
 
-    if self_update && check_rustup_update(cfg.process).await? {
+    if self_update && check_rustup_update(&DownloadCfg::new(cfg)).await? {
         update_available = true;
     }
 
@@ -937,10 +938,13 @@ async fn update(
     if let Some(p) = opts.profile {
         cfg.set_profile_override(p);
     }
+
     let cfg = &cfg;
     if cfg.get_profile()? == Profile::Complete {
         warn!("{}", common::WARN_COMPLETE_PROFILE);
     }
+
+    let dl_cfg = DownloadCfg::new(cfg);
     let names = opts.toolchain;
     if !names.is_empty() {
         for name in names {
@@ -994,7 +998,7 @@ async fn update(
             }
         }
         if self_update {
-            exit_code &= self_update::self_update(cfg.process).await?;
+            exit_code &= self_update::self_update(&dl_cfg).await?;
         }
     } else if ensure_active_toolchain {
         let (toolchain, reason) = cfg.ensure_active_toolchain(force_non_host, true).await?;
@@ -1003,7 +1007,7 @@ async fn update(
     } else {
         exit_code &= common::update_all_channels(cfg, opts.force).await?;
         if self_update {
-            exit_code &= self_update::self_update(cfg.process).await?;
+            exit_code &= self_update::self_update(&dl_cfg).await?;
         }
 
         info!("cleaning up downloads & tmp directories");
@@ -1012,7 +1016,7 @@ async fn update(
     }
 
     if !cfg!(feature = "no-self-update") && self_update_mode == SelfUpdateMode::CheckOnly {
-        check_rustup_update(cfg.process).await?;
+        check_rustup_update(&dl_cfg).await?;
     }
 
     if cfg!(feature = "no-self-update") {

src/cli/self_update.rs

@@ -50,6 +50,7 @@ use serde::{Deserialize, Serialize};
 use termcolor::Color;
 use tracing::{error, info, trace, warn};
 
+use crate::dist::download::DownloadCfg;
 use crate::{
     DUP_TOOLS, TOOLS,
     cli::{
@@ -541,7 +542,7 @@ pub(crate) async fn install(
     let mut term = cfg.process.stdout();
 
     #[cfg(windows)]
-    windows::maybe_install_msvc(&mut term, no_prompt, quiet, &opts, process).await?;
+    windows::maybe_install_msvc(&mut term, no_prompt, &opts, &*cfg).await?;
 
     if !no_prompt {
         let msg = pre_install_msg(opts.no_modify_path, cfg.process)?;
@@ -576,7 +577,7 @@ pub(crate) async fn install(
         // window closes.
         #[cfg(windows)]
         if !no_prompt {
-            windows::ensure_prompt(process)?;
+            windows::ensure_prompt(cfg.process)?;
         }
 
         return Ok(utils::ExitCode(1));
@@ -620,7 +621,7 @@ pub(crate) async fn install(
         // On windows, where installation happens in a console
         // that may have opened just for this purpose, require
         // the user to press a key to continue.
-        windows::ensure_prompt(process)?;
+        windows::ensure_prompt(cfg.process)?;
     }
 
     Ok(exit_code)
@@ -1105,7 +1106,7 @@ pub(crate) fn self_update_permitted(explicit: bool) -> Result<SelfUpdatePermissi
 }
 
 /// Performs all of a self-update: check policy, download, apply and exit.
-pub(crate) async fn self_update(process: &Process) -> Result<utils::ExitCode> {
+pub(crate) async fn self_update(dl_cfg: &DownloadCfg<'_>) -> Result<utils::ExitCode> {
     match self_update_permitted(false)? {
         SelfUpdatePermission::HardFail => {
             error!("Unable to self-update.  STOP");
@@ -1116,13 +1117,13 @@ pub(crate) async fn self_update(process: &Process) -> Result<utils::ExitCode> {
         SelfUpdatePermission::Permit => {}
     }
 
-    let setup_path = prepare_update(process).await?;
+    let setup_path = prepare_update(dl_cfg).await?;
 
     if let Some(setup_path) = &setup_path {
         return run_update(setup_path);
     } else {
         // Try again in case we emitted "tool `{}` is already installed" last time.
-        install_proxies(process)?;
+        install_proxies(dl_cfg.process)?;
     }
 
     Ok(utils::ExitCode(0))
@@ -1167,7 +1168,7 @@ pub(crate) async fn update(cfg: &Cfg<'_>) -> Result<utils::ExitCode> {
         Permit => {}
     }
 
-    match prepare_update(cfg.process).await? {
+    match prepare_update(&DownloadCfg::new(cfg)).await? {
         Some(setup_path) => {
             let Some(version) = get_and_parse_new_rustup_version(&setup_path) else {
                 error!("failed to get rustup version");
@@ -1220,8 +1221,8 @@ fn parse_new_rustup_version(version: String) -> String {
     String::from(matched_version)
 }
 
-pub(crate) async fn prepare_update(process: &Process) -> Result<Option<PathBuf>> {
-    let cargo_home = process.cargo_home()?;
+pub(crate) async fn prepare_update(dl_cfg: &DownloadCfg<'_>) -> Result<Option<PathBuf>> {
+    let cargo_home = dl_cfg.process.cargo_home()?;
     let rustup_path = cargo_home.join(format!("bin{MAIN_SEPARATOR}rustup{EXE_SUFFIX}"));
     let setup_path = cargo_home.join(format!("bin{MAIN_SEPARATOR}rustup-init{EXE_SUFFIX}"));
 
@@ -1243,22 +1244,22 @@ pub(crate) async fn prepare_update(process: &Process) -> Result<Option<PathBuf>>
     // If someone really wants to use another version, they still can enforce
     // that using the environment variable RUSTUP_OVERRIDE_HOST_TRIPLE.
     #[cfg(windows)]
-    let triple = dist::TargetTriple::from_host(process).unwrap_or(triple);
+    let triple = dist::TargetTriple::from_host(dl_cfg.process).unwrap_or(triple);
 
     // Get update root.
-    let update_root = update_root(process);
+    let update_root = update_root(dl_cfg.process);
 
     // Get current version
     let current_version = env!("CARGO_PKG_VERSION");
 
     // Get available version
     info!("checking for self-update (current version: {current_version})");
-    let available_version = match process.var_opt("RUSTUP_VERSION")? {
+    let available_version = match dl_cfg.process.var_opt("RUSTUP_VERSION")? {
         Some(ver) => {
             info!("`RUSTUP_VERSION` has been set to `{ver}`");
             ver
         }
-        None => get_available_rustup_version(process).await?,
+        None => get_available_rustup_version(dl_cfg).await?,
     };
 
     // If up-to-date
@@ -1274,16 +1275,23 @@ pub(crate) async fn prepare_update(process: &Process) -> Result<Option<PathBuf>>
 
     // Download new version
     info!("downloading self-update (new version: {available_version})");
-    download_file(&download_url, &setup_path, None, &|_| (), process).await?;
+    download_file(
+        &download_url,
+        &setup_path,
+        None,
+        &dl_cfg.notifier,
+        dl_cfg.process,
+    )
+    .await?;
 
     // Mark as executable
     utils::make_executable(&setup_path)?;
 
     Ok(Some(setup_path))
 }
 
-async fn get_available_rustup_version(process: &Process) -> Result<String> {
-    let update_root = update_root(process);
+async fn get_available_rustup_version(dl_cfg: &DownloadCfg<'_>) -> Result<String> {
+    let update_root = update_root(dl_cfg.process);
     let tempdir = tempfile::Builder::new()
         .prefix("rustup-update")
         .tempdir()
@@ -1293,7 +1301,14 @@ async fn get_available_rustup_version(process: &Process) -> Result<String> {
     let release_file_url = format!("{update_root}/release-stable.toml");
     let release_file_url = utils::parse_url(&release_file_url)?;
     let release_file = tempdir.path().join("release-stable.toml");
-    download_file(&release_file_url, &release_file, None, &|_| (), process).await?;
+    download_file(
+        &release_file_url,
+        &release_file,
+        None,
+        &dl_cfg.notifier,
+        dl_cfg.process,
+    )
+    .await?;
     let release_toml_str = utils::read_file("rustup release", &release_file)?;
     let release_toml = toml::from_str::<RustupManifest>(&release_toml_str)
         .context("unable to parse rustup release file")?;
@@ -1341,13 +1356,13 @@ impl fmt::Display for SchemaVersion {
 }
 
 /// Returns whether an update was available
-pub(crate) async fn check_rustup_update(process: &Process) -> anyhow::Result<bool> {
-    let mut t = process.stdout();
+pub(crate) async fn check_rustup_update(dl_cfg: &DownloadCfg<'_>) -> anyhow::Result<bool> {
+    let mut t = dl_cfg.process.stdout();
     // Get current rustup version
     let current_version = env!("CARGO_PKG_VERSION");
 
     // Get available rustup version
-    let available_version = get_available_rustup_version(process).await?;
+    let available_version = get_available_rustup_version(dl_cfg).await?;
 
     let _ = t.attr(Attr::Bold);
     write!(t.lock(), "rustup - ")?;

src/cli/self_update/windows.rs

@@ -5,7 +5,6 @@ use std::io::Write;
 use std::os::windows::ffi::OsStrExt;
 use std::path::Path;
 use std::process::Command;
-use std::sync::{Arc, Mutex};
 #[cfg(any(test, feature = "test"))]
 use std::sync::{LockResult, MutexGuard};
 
@@ -20,8 +19,10 @@ use windows_sys::Win32::Foundation::{ERROR_FILE_NOT_FOUND, ERROR_INVALID_DATA};
 use super::super::errors::*;
 use super::common;
 use super::{InstallOpts, install_bins, report_error};
-use crate::cli::{download_tracker::DownloadTracker, markdown::md};
+use crate::cli::markdown::md;
+use crate::config::Cfg;
 use crate::dist::TargetTriple;
+use crate::dist::download::DownloadCfg;
 use crate::download::download_file;
 use crate::process::{ColorableTerminal, Process};
 use crate::utils;
@@ -91,36 +92,35 @@ pub(crate) fn choose_vs_install(process: &Process) -> Result<Option<VsInstallPla
 pub(super) async fn maybe_install_msvc(
     term: &mut ColorableTerminal,
     no_prompt: bool,
-    quiet: bool,
     opts: &InstallOpts<'_>,
-    process: &Process,
+    cfg: &Cfg<'_>,
 ) -> Result<()> {
-    let Some(plan) = do_msvc_check(opts, process) else {
+    let Some(plan) = do_msvc_check(opts, cfg.process) else {
         return Ok(());
     };
 
     if no_prompt {
         warn!("installing msvc toolchain without its prerequisites");
-    } else if !quiet && plan == VsInstallPlan::Automatic {
+    } else if !cfg.quiet && plan == VsInstallPlan::Automatic {
         md(term, MSVC_AUTO_INSTALL_MESSAGE);
-        match choose_vs_install(process)? {
+        match choose_vs_install(cfg.process)? {
             Some(VsInstallPlan::Automatic) => {
-                match try_install_msvc(opts, process).await {
+                match try_install_msvc(opts, cfg).await {
                     Err(e) => {
                         // Make sure the console doesn't exit before the user can
                         // see the error and give the option to continue anyway.
-                        report_error(&e, process);
-                        if !common::question_bool("\nContinue?", false, process)? {
+                        report_error(&e, cfg.process);
+                        if !common::question_bool("\nContinue?", false, cfg.process)? {
                             info!("aborting installation");
                         }
                     }
-                    Ok(ContinueInstall::No) => ensure_prompt(process)?,
+                    Ok(ContinueInstall::No) => ensure_prompt(cfg.process)?,
                     _ => {}
                 }
             }
             Some(VsInstallPlan::Manual) => {
                 md(term, MSVC_MANUAL_INSTALL_MESSAGE);
-                if !common::question_bool("\nContinue?", false, process)? {
+                if !common::question_bool("\nContinue?", false, cfg.process)? {
                     info!("aborting installation");
                 }
             }
@@ -129,7 +129,7 @@ pub(super) async fn maybe_install_msvc(
     } else {
         md(term, MSVC_MESSAGE);
         md(term, MSVC_MANUAL_INSTALL_MESSAGE);
-        if !common::question_bool("\nContinue?", false, process)? {
+        if !common::question_bool("\nContinue?", false, cfg.process)? {
             info!("aborting installation");
         }
     }
@@ -260,7 +260,7 @@ pub(crate) enum ContinueInstall {
 /// but the rustup install should not be continued at this time.
 pub(crate) async fn try_install_msvc(
     opts: &InstallOpts<'_>,
-    process: &Process,
+    cfg: &Cfg<'_>,
 ) -> Result<ContinueInstall> {
     // download the installer
     let visual_studio_url = utils::parse_url("https://aka.ms/vs/17/release/vs_community.exe")?;
@@ -271,23 +271,14 @@ pub(crate) async fn try_install_msvc(
         .context("error creating temp directory")?;
 
     let visual_studio = tempdir.path().join("vs_setup.exe");
-    let download_tracker = Arc::new(Mutex::new(DownloadTracker::new_with_display_progress(
-        true, process,
-    )));
-    download_tracker
-        .lock()
-        .unwrap()
-        .download_finished(visual_studio_url.as_str());
-
+    let dl_cfg = DownloadCfg::new(cfg);
     info!("downloading Visual Studio installer");
     download_file(
         &visual_studio_url,
         &visual_studio,
         None,
-        &move |n| {
-            download_tracker.lock().unwrap().handle_notification(&n);
-        },
-        process,
+        &dl_cfg.notifier,
+        dl_cfg.process,
     )
     .await?;
 
@@ -304,7 +295,7 @@ pub(crate) async fn try_install_msvc(
 
     // It's possible an earlier or later version of the Windows SDK has been
     // installed separately from Visual Studio so installing it can be skipped.
-    if !has_windows_sdk_libs(process) {
+    if !has_windows_sdk_libs(cfg.process) {
         cmd.args([
             "--add",
             "Microsoft.VisualStudio.Component.Windows11SDK.22000",
@@ -337,8 +328,8 @@ pub(crate) async fn try_install_msvc(
                 // It's possible that the installer returned a non-zero exit code
                 // even though the required components were successfully installed.
                 // In that case we warn about the error but continue on.
-                let have_msvc = do_msvc_check(opts, process).is_none();
-                let has_libs = has_windows_sdk_libs(process);
+                let have_msvc = do_msvc_check(opts, cfg.process).is_none();
+                let has_libs = has_windows_sdk_libs(cfg.process);
                 if have_msvc && has_libs {
                     warn!("Visual Studio is installed but a problem occurred during installation");
                     warn!("{}", err);