notifications: privatize Notification type

Author: djc

src/dist/download.rs

@@ -21,7 +21,7 @@ pub struct DownloadCfg<'a> {
     pub dist_root: &'a str,
     pub tmp_cx: &'a temp::Context,
     pub download_dir: &'a PathBuf,
-    pub notify_handler: &'a dyn Fn(Notification<'_>),
+    pub(crate) notify_handler: &'a dyn Fn(Notification<'_>),
     pub process: &'a Process,
 }
 

src/dist/manifestation.rs

@@ -315,7 +315,7 @@ impl Manifestation {
     }
 
     #[cfg(test)]
-    pub fn uninstall(
+    pub(crate) fn uninstall(
         &self,
         manifest: &Manifest,
         tmp_cx: &temp::Context,

src/download/mod.rs

@@ -96,7 +96,7 @@ async fn download_file_(
     use sha2::Digest;
     use std::cell::RefCell;
 
-    notify_handler(Notification::DownloadingFile(url, path));
+    notify_handler(Notification::DownloadingFile(url));
 
     let hasher = RefCell::new(hasher);
 

src/notifications.rs

@@ -10,15 +10,13 @@ use crate::utils::units;
 use crate::{dist::ToolchainDesc, toolchain::ToolchainName, utils::notify::NotificationLevel};
 
 #[derive(Debug)]
-pub enum Notification<'a> {
-    Extracting(&'a Path, &'a Path),
+pub(crate) enum Notification<'a> {
     ComponentAlreadyInstalled(&'a str),
     CantReadUpdateHash(&'a Path),
     NoUpdateHash(&'a Path),
     ChecksumValid(&'a str),
     FileAlreadyDownloaded,
     CachedFileChecksumFailed,
-    ExtensionNotInstalled(&'a str),
     MissingInstalledComponent(&'a str),
     /// The URL of the download is passed as the last argument, to allow us to track concurrent downloads.
     DownloadingComponent(&'a str, &'a TargetTriple, Option<&'a TargetTriple>, &'a str),
@@ -30,11 +28,9 @@ pub enum Notification<'a> {
     DownloadingLegacyManifest,
     SkippingNightlyMissingComponent(&'a ToolchainDesc, &'a Manifest, &'a [Component]),
     ForcingUnavailableComponent(&'a str),
-    ComponentUnavailable(&'a str, Option<&'a TargetTriple>),
     StrayHash(&'a Path),
-    SignatureInvalid(&'a str),
     RetryingDownload(&'a str),
-    DownloadingFile(&'a Url, &'a Path),
+    DownloadingFile(&'a Url),
     /// 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>),
@@ -85,8 +81,7 @@ impl Notification<'_> {
             | NoUpdateHash(_)
             | FileAlreadyDownloaded
             | DownloadingLegacyManifest => NotificationLevel::Debug,
-            Extracting(_, _)
-            | DownloadingComponent(_, _, _, _)
+            DownloadingComponent(_, _, _, _)
             | InstallingComponent(_, _, _)
             | RemovingComponent(_, _, _)
             | RemovingOldComponent(_, _, _)
@@ -96,15 +91,12 @@ impl Notification<'_> {
             | RetryingDownload(_)
             | DownloadedManifest(_, _) => NotificationLevel::Info,
             CantReadUpdateHash(_)
-            | ExtensionNotInstalled(_)
             | MissingInstalledComponent(_)
             | CachedFileChecksumFailed
-            | ComponentUnavailable(_, _)
             | ForcingUnavailableComponent(_)
             | StrayHash(_) => NotificationLevel::Warn,
-            SignatureInvalid(_) => NotificationLevel::Warn,
             SetDefaultBufferSize(_) => NotificationLevel::Trace,
-            DownloadingFile(_, _)
+            DownloadingFile(_)
             | DownloadContentLengthReceived(_, _)
             | DownloadDataReceived(_, _)
             | DownloadFinished(_)
@@ -139,18 +131,16 @@ impl Display for Notification<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> {
         use self::Notification::*;
         match self {
-            Extracting(_, _) => write!(f, "extracting..."),
             ComponentAlreadyInstalled(c) => write!(f, "component {c} is up to date"),
             CantReadUpdateHash(path) => write!(
                 f,
                 "can't read update hash file: '{}', can't skip update...",
                 path.display()
             ),
             NoUpdateHash(path) => write!(f, "no update hash at: '{}'", path.display()),
-            ChecksumValid(_) => write!(f, "checksum passed"),
+            ChecksumValid(url) => write!(f, "checksum passed for {url}"),
             FileAlreadyDownloaded => write!(f, "reusing previously downloaded file"),
             CachedFileChecksumFailed => write!(f, "bad checksum for cached download"),
-            ExtensionNotInstalled(c) => write!(f, "extension '{c}' was not installed"),
             MissingInstalledComponent(c) => {
                 write!(f, "during uninstall component {c} was not found")
             }
@@ -195,13 +185,6 @@ impl Display for Notification<'_> {
                 write!(f, "latest update on {date}, no rust version")
             }
             DownloadingLegacyManifest => write!(f, "manifest not found. trying legacy manifest"),
-            ComponentUnavailable(pkg, toolchain) => {
-                if let Some(tc) = toolchain {
-                    write!(f, "component '{pkg}' is not available on target '{tc}'")
-                } else {
-                    write!(f, "component '{pkg}' is not available")
-                }
-            }
             StrayHash(path) => write!(
                 f,
                 "removing stray hash found at '{}' in order to continue",
@@ -226,15 +209,14 @@ impl Display for Notification<'_> {
             ForcingUnavailableComponent(component) => {
                 write!(f, "Force-skipping unavailable component '{component}'")
             }
-            SignatureInvalid(url) => write!(f, "Signature verification failed for '{url}'"),
             RetryingDownload(url) => write!(f, "retrying download for '{url}'"),
             Error(e) => write!(f, "error: '{e}'"),
             SetDefaultBufferSize(size) => write!(
                 f,
                 "using up to {} of RAM to unpack components",
                 units::Size::new(*size)
             ),
-            DownloadingFile(url, _) => write!(f, "downloading file from: '{url}'"),
+            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"),