Inline utils::notifications::Notification variants into top-level Notification

djc · djc · commit 8e90e40c142d · 2025-09-22T15:25:50.000+02:00
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -22,7 +22,7 @@ use crate::{
     notifications::Notification,
     process::{Process, terminalsource},
     toolchain::{LocalToolchainName, Toolchain, ToolchainName},
-    utils::{self, notifications as util_notifications, notify::NotificationLevel},
+    utils::{self, notify::NotificationLevel},
 };
 
 pub(crate) const WARN_COMPLETE_PROFILE: &str = "downloading with complete profile isn't recommended unless you are a developer of the rust language";
@@ -139,7 +139,7 @@ impl Notifier {
             return;
         }
 
-        if let Notification::Utils(util_notifications::Notification::SetDefaultBufferSize(_)) = &n {
+        if let Notification::SetDefaultBufferSize(_) = &n {
             if *self.ram_notice_shown.borrow() {
                 return;
             } else {
diff --git a/src/cli/download_tracker.rs b/src/cli/download_tracker.rs
@@ -4,7 +4,6 @@ use std::time::{Duration, Instant};
 
 use crate::notifications::Notification;
 use crate::process::Process;
-use crate::utils::Notification as Un;
 
 /// Tracks download progress and displays information about it to a terminal.
 ///
@@ -39,25 +38,25 @@ impl DownloadTracker {
 
     pub(crate) fn handle_notification(&mut self, n: &Notification<'_>) -> bool {
         match *n {
-            Notification::Utils(Un::DownloadContentLengthReceived(content_len, url)) => {
+            Notification::DownloadContentLengthReceived(content_len, url) => {
                 if let Some(url) = url {
                     self.content_length_received(content_len, url);
                 }
                 true
             }
-            Notification::Utils(Un::DownloadDataReceived(data, url)) => {
+            Notification::DownloadDataReceived(data, url) => {
                 if let Some(url) = url {
                     self.data_received(data.len(), url);
                 }
                 true
             }
-            Notification::Utils(Un::DownloadFinished(url)) => {
+            Notification::DownloadFinished(url) => {
                 if let Some(url) = url {
                     self.download_finished(url);
                 }
                 true
             }
-            Notification::Utils(Un::DownloadFailed(url)) => {
+            Notification::DownloadFailed(url) => {
                 self.download_failed(url);
                 false
             }
diff --git a/src/cli/self_update.rs b/src/cli/self_update.rs
@@ -66,7 +66,8 @@ use crate::{
         DistributableToolchain, MaybeOfficialToolchainName, ResolvableToolchainName, Toolchain,
         ToolchainName,
     },
-    utils::{self, Notification},
+    notifications::Notification,
+    utils,
 };
 
 #[cfg(unix)]
diff --git a/src/cli/self_update/unix.rs b/src/cli/self_update/unix.rs
@@ -7,7 +7,8 @@ use tracing::{error, warn};
 use super::install_bins;
 use super::shell::{self, Posix, UnixShell};
 use crate::process::Process;
-use crate::utils::{self, Notification};
+use crate::utils;
+use crate::notifications::Notification;
 
 // If the user is trying to install with sudo, on some systems this will
 // result in writing root-owned files to the user's home directory, because
diff --git a/src/diskio/mod.rs b/src/diskio/mod.rs
@@ -66,7 +66,7 @@ use std::{fmt::Debug, fs::OpenOptions};
 use anyhow::Result;
 
 use crate::process::Process;
-use crate::utils::notifications::Notification;
+use crate::notifications::Notification;
 use threaded::PoolReference;
 
 /// Carries the implementation specific data for complete file transfers into the executor.
diff --git a/src/diskio/threaded.rs b/src/diskio/threaded.rs
@@ -15,7 +15,7 @@ use sharded_slab::pool::{OwnedRef, OwnedRefMut};
 use tracing::debug;
 
 use super::{CompletedIo, Executor, Item, perform};
-use crate::utils::notifications::Notification;
+use crate::notifications::Notification;
 
 #[derive(Copy, Clone, Debug, Enum)]
 pub(crate) enum Bucket {
diff --git a/src/dist/component/package.rs b/src/dist/component/package.rs
@@ -15,10 +15,11 @@ use tracing::warn;
 use crate::diskio::{CompletedIo, Executor, FileBuffer, IO_CHUNK_SIZE, Item, Kind, get_executor};
 use crate::dist::component::components::*;
 use crate::dist::component::transaction::*;
+use crate::notifications::Notification;
 use crate::dist::temp;
 use crate::errors::*;
 use crate::process::Process;
-use crate::utils::{self, Notification};
+use crate::utils;
 
 /// The current metadata revision used by rust-installer
 pub(crate) const INSTALLER_VERSION: &str = "3";
diff --git a/src/dist/download.rs b/src/dist/download.rs
@@ -209,10 +209,7 @@ impl<'a> DownloadCfg<'a> {
 
 fn file_hash(path: &Path, notify_handler: &dyn Fn(Notification<'_>)) -> Result<String> {
     let mut hasher = Sha256::new();
-    let notification_converter = |notification: crate::utils::Notification<'_>| {
-        notify_handler(notification.into());
-    };
-    let mut downloaded = utils::FileReaderWithProgress::new_file(path, &notification_converter)?;
+    let mut downloaded = utils::FileReaderWithProgress::new_file(path, notify_handler)?;
     use std::io::Read;
     let mut buf = vec![0; 32768];
     while let Ok(n) = downloaded.read(&mut buf) {
diff --git a/src/dist/manifestation.rs b/src/dist/manifestation.rs
@@ -265,18 +265,16 @@ impl Manifestation {
                 component.target.as_ref(),
             ));
 
-            let notification_converter = |notification: crate::utils::Notification<'_>| {
-                (download_cfg.notify_handler)(notification.into());
-            };
-
             let cx = PackageContext {
                 tmp_cx,
-                notify_handler: Some(&notification_converter),
+                notify_handler: Some(download_cfg.notify_handler),
                 process: download_cfg.process,
             };
 
-            let reader =
-                utils::FileReaderWithProgress::new_file(&installer_file, &notification_converter)?;
+            let reader = utils::FileReaderWithProgress::new_file(
+                &installer_file,
+                download_cfg.notify_handler,
+            )?;
             let package = match format {
                 CompressionKind::GZip => &TarGzPackage::new(reader, &cx)? as &dyn Package,
                 CompressionKind::XZ => &TarXzPackage::new(reader, &cx)?,
@@ -487,14 +485,10 @@ impl Manifestation {
         }
 
         // Install all the components in the installer
-        let notification_converter = |notification: crate::utils::Notification<'_>| {
-            notify_handler(notification.into());
-        };
-        let reader =
-            utils::FileReaderWithProgress::new_file(&installer_file, &notification_converter)?;
+        let reader = utils::FileReaderWithProgress::new_file(&installer_file, notify_handler)?;
         let cx = PackageContext {
             tmp_cx,
-            notify_handler: Some(&notification_converter),
+            notify_handler: Some(notify_handler),
             process,
         };
 
diff --git a/src/dist/temp.rs b/src/dist/temp.rs
@@ -103,7 +103,7 @@ impl Context {
             // This is technically racey, but the probability of getting the same
             // random names at exactly the same time is... low.
             if !raw::path_exists(&temp_dir) {
-                (self.notify_handler)(Notification::CreatingDirectory(&temp_dir));
+                (self.notify_handler)(Notification::CreatingDirectory("temp", &temp_dir));
                 fs::create_dir(&temp_dir)
                     .with_context(|| CreatingError::Directory(PathBuf::from(&temp_dir)))?;
                 return Ok(Dir {
diff --git a/src/download/mod.rs b/src/download/mod.rs
@@ -20,7 +20,7 @@ use tracing::info;
 use tracing::warn;
 use url::Url;
 
-use crate::{errors::RustupError, process::Process, utils::Notification};
+use crate::{errors::RustupError, notifications::Notification, process::Process};
 
 #[cfg(test)]
 mod tests;
diff --git a/src/notifications.rs b/src/notifications.rs
@@ -2,9 +2,12 @@ use std::fmt::{self, Display};
 use std::io;
 use std::path::{Path, PathBuf};
 
+use url::Url;
+
 use crate::dist::TargetTriple;
 use crate::dist::manifest::{Component, Manifest};
 use crate::settings::MetadataVersion;
+use crate::utils::units;
 use crate::{dist::ToolchainDesc, toolchain::ToolchainName, utils::notify::NotificationLevel};
 
 #[derive(Debug)]
@@ -34,10 +37,37 @@ pub enum Notification<'a> {
     StrayHash(&'a Path),
     SignatureInvalid(&'a str),
     RetryingDownload(&'a str),
-    Utils(crate::utils::Notification<'a>),
+    CreatingDirectory(&'a str, &'a Path),
+    LinkingDirectory(&'a Path, &'a Path),
+    CopyingDirectory(&'a Path, &'a Path),
+    RemovingDirectory(&'a str, &'a Path),
+    DownloadingFile(&'a Url, &'a Path),
+    /// Received the Content-Length of the to-be downloaded data with
+    /// the respective URL of the download (for tracking concurrent downloads).
+    DownloadContentLengthReceived(u64, Option<&'a str>),
+    /// Received some data.
+    DownloadDataReceived(&'a [u8], Option<&'a str>),
+    /// Download has finished.
+    DownloadFinished(Option<&'a str>),
+    /// Download has failed.
+    DownloadFailed(&'a str),
+    NoCanonicalPath(&'a Path),
+    ResumingPartialDownload,
+    /// This would make more sense as a crate::notifications::Notification
+    /// member, but the notification callback is already narrowed to
+    /// utils::notifications by the time tar unpacking is called.
+    SetDefaultBufferSize(usize),
+    Error(String),
+    UsingCurl,
+    UsingReqwest,
+    /// Renaming encountered a file in use error and is retrying.
+    /// The InUse aspect is a heuristic - the OS specifies
+    /// Permission denied, but as we work in users home dirs and
+    /// running programs like virus scanner are known to cause this
+    /// the heuristic is quite good.
+    RenameInUse(&'a Path, &'a Path),
     CreatingRoot(&'a Path),
     CreatingFile(&'a Path),
-    CreatingDirectory(&'a Path),
     FileDeletion(&'a Path, io::Result<()>),
     DirectoryDeletion(&'a Path, io::Result<()>),
     SetAutoInstall(&'a str),
@@ -65,12 +95,6 @@ pub enum Notification<'a> {
     },
 }
 
-impl<'a> From<crate::utils::Notification<'a>> for Notification<'a> {
-    fn from(n: crate::utils::Notification<'a>) -> Self {
-        Notification::Utils(n)
-    }
-}
-
 impl Notification<'_> {
     pub(crate) fn level(&self) -> NotificationLevel {
         use self::Notification::*;
@@ -99,8 +123,23 @@ impl Notification<'_> {
             | StrayHash(_) => NotificationLevel::Warn,
             NonFatalError(_) => NotificationLevel::Error,
             SignatureInvalid(_) => NotificationLevel::Warn,
-            Utils(n) => n.level(),
-            CreatingRoot(_) | CreatingFile(_) | CreatingDirectory(_) => NotificationLevel::Debug,
+            SetDefaultBufferSize(_) => NotificationLevel::Trace,
+            CreatingDirectory(_, _)
+            | RemovingDirectory(_, _)
+            | LinkingDirectory(_, _)
+            | CopyingDirectory(_, _)
+            | DownloadingFile(_, _)
+            | DownloadContentLengthReceived(_, _)
+            | DownloadDataReceived(_, _)
+            | DownloadFinished(_)
+            | DownloadFailed(_)
+            | ResumingPartialDownload
+            | UsingCurl
+            | UsingReqwest => NotificationLevel::Debug,
+            RenameInUse(_, _) => NotificationLevel::Info,
+            NoCanonicalPath(_) => NotificationLevel::Warn,
+            Error(_) => NotificationLevel::Error,
+            CreatingRoot(_) | CreatingFile(_) => NotificationLevel::Debug,
             FileDeletion(_, result) | DirectoryDeletion(_, result) => {
                 if result.is_ok() {
                     NotificationLevel::Debug
@@ -225,10 +264,37 @@ impl Display for Notification<'_> {
             }
             SignatureInvalid(url) => write!(f, "Signature verification failed for '{url}'"),
             RetryingDownload(url) => write!(f, "retrying download for '{url}'"),
-            Utils(n) => n.fmt(f),
+            CreatingDirectory(name, path) => {
+                write!(f, "creating {} directory: '{}'", name, path.display())
+            }
+            Error(e) => write!(f, "error: '{e}'"),
+            LinkingDirectory(_, dest) => write!(f, "linking directory from: '{}'", dest.display()),
+            CopyingDirectory(src, _) => write!(f, "copying directory from: '{}'", src.display()),
+            RemovingDirectory(name, path) => {
+                write!(f, "removing {} directory: '{}'", name, path.display())
+            }
+            RenameInUse(src, dest) => write!(
+                f,
+                "retrying renaming '{}' to '{}'",
+                src.display(),
+                dest.display()
+            ),
+            SetDefaultBufferSize(size) => write!(
+                f,
+                "using up to {} of RAM to unpack components",
+                units::Size::new(*size)
+            ),
+            DownloadingFile(url, _) => write!(f, "downloading file from: '{url}'"),
+            DownloadContentLengthReceived(len, _) => write!(f, "download size is: '{len}'"),
+            DownloadDataReceived(data, _) => write!(f, "received some data of size {}", data.len()),
+            DownloadFinished(_) => write!(f, "download finished"),
+            DownloadFailed(_) => write!(f, "download failed"),
+            NoCanonicalPath(path) => write!(f, "could not canonicalize path: '{}'", path.display()),
+            ResumingPartialDownload => write!(f, "resuming partial download"),
+            UsingCurl => write!(f, "downloading with curl"),
+            UsingReqwest => write!(f, "downloading with reqwest"),
             CreatingRoot(path) => write!(f, "creating temp root: {}", path.display()),
             CreatingFile(path) => write!(f, "creating temp file: {}", path.display()),
-            CreatingDirectory(path) => write!(f, "creating temp directory: {}", path.display()),
             FileDeletion(path, result) => {
                 if result.is_ok() {
                     write!(f, "deleted temp file: {}", path.display())
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
@@ -18,10 +18,10 @@ use crate::process::Process;
 
 #[cfg(not(windows))]
 pub(crate) use crate::utils::raw::find_cmd;
+pub(crate) use crate::utils::raw::is_directory;
 pub use crate::utils::raw::{is_file, path_exists};
-pub(crate) use crate::utils::{notifications::Notification, raw::is_directory};
+use crate::notifications::Notification;
 
-pub(crate) mod notifications;
 pub(crate) mod notify;
 pub mod raw;
 pub(crate) mod units;
diff --git a/src/utils/notifications.rs b/src/utils/notifications.rs

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@ use std::time::{Duration, Instant};`
`4`	`4`
`5`	`5`	`use crate::notifications::Notification;`
`6`	`6`	`use crate::process::Process;`
`7`		`-use crate::utils::Notification as Un;`
`8`	`7`
`9`	`8`	`/// Tracks download progress and displays information about it to a terminal.`
`10`	`9`	`///`
`@@ -39,25 +38,25 @@ impl DownloadTracker {`
`39`	`38`
`40`	`39`	`pub(crate) fn handle_notification(&mut self, n: &Notification<'_>) -> bool {`
`41`	`40`	`match *n {`
`42`		`- Notification::Utils(Un::DownloadContentLengthReceived(content_len, url)) => {`
	`41`	`+ Notification::DownloadContentLengthReceived(content_len, url) => {`
`43`	`42`	`if let Some(url) = url {`
`44`	`43`	`self.content_length_received(content_len, url);`
`45`	`44`	`}`
`46`	`45`	`true`
`47`	`46`	`}`
`48`		`- Notification::Utils(Un::DownloadDataReceived(data, url)) => {`
	`47`	`+ Notification::DownloadDataReceived(data, url) => {`
`49`	`48`	`if let Some(url) = url {`
`50`	`49`	`self.data_received(data.len(), url);`
`51`	`50`	`}`
`52`	`51`	`true`
`53`	`52`	`}`
`54`		`- Notification::Utils(Un::DownloadFinished(url)) => {`
	`53`	`+ Notification::DownloadFinished(url) => {`
`55`	`54`	`if let Some(url) = url {`
`56`	`55`	`self.download_finished(url);`
`57`	`56`	`}`
`58`	`57`	`true`
`59`	`58`	`}`
`60`		`- Notification::Utils(Un::DownloadFailed(url)) => {`
	`59`	`+ Notification::DownloadFailed(url) => {`
`61`	`60`	`self.download_failed(url);`
`62`	`61`	`false`
`63`	`62`	`}`