notifications: log directly when creating directories

Author: djc

src/cli/self_update.rs

@@ -770,7 +770,7 @@ fn install_bins(process: &Process) -> Result<()> {
     let this_exe_path = utils::current_exe()?;
     let rustup_path = bin_path.join(format!("rustup{EXE_SUFFIX}"));
 
-    utils::ensure_dir_exists("bin", &bin_path, &|_: Notification<'_>| {})?;
+    utils::ensure_dir_exists("bin", &bin_path)?;
     // NB: Even on Linux we can't just copy the new binary over the (running)
     // old binary; we must unlink it first.
     if rustup_path.exists() {

src/cli/self_update/unix.rs

@@ -98,7 +98,7 @@ pub(crate) fn do_add_to_path(process: &Process) -> Result<()> {
                     rc.display()
                 )
             })?;
-            utils::ensure_dir_exists("rcfile dir", rc_dir, &|_: Notification<'_>| ())?;
+            utils::ensure_dir_exists("rcfile dir", rc_dir)?;
             utils::append_file("rcfile", &rc, cmd_to_write)
                 .with_context(|| format!("could not amend shell profile: '{}'", rc.display()))?;
         }

src/config.rs

@@ -247,7 +247,7 @@ impl<'a> Cfg<'a> {
         // Set up the rustup home directory
         let rustup_dir = process.rustup_home()?;
 
-        utils::ensure_dir_exists("home", &rustup_dir, notify_handler.as_ref())?;
+        utils::ensure_dir_exists("home", &rustup_dir)?;
 
         let settings_file = SettingsFile::new(rustup_dir.join("settings.toml"));
         settings_file.with(|s| {
@@ -411,9 +411,7 @@ impl<'a> Cfg<'a> {
     }
 
     pub(crate) fn ensure_toolchains_dir(&self) -> Result<(), anyhow::Error> {
-        utils::ensure_dir_exists("toolchains", &self.toolchains_dir, &|n| {
-            (self.notify_handler)(n)
-        })?;
+        utils::ensure_dir_exists("toolchains", &self.toolchains_dir)?;
         Ok(())
     }
 
@@ -437,11 +435,7 @@ impl<'a> Cfg<'a> {
         create_parent: bool,
     ) -> Result<PathBuf> {
         if create_parent {
-            utils::ensure_dir_exists(
-                "update-hash",
-                &self.update_hash_dir,
-                self.notify_handler.as_ref(),
-            )?;
+            utils::ensure_dir_exists("update-hash", &self.update_hash_dir)?;
         }
 
         Ok(self.update_hash_dir.join(toolchain.to_string()))

src/dist/component/transaction.rs

@@ -268,7 +268,7 @@ impl<'a> ChangedItem<'a> {
             }))
         } else {
             if let Some(p) = abs_path.parent() {
-                utils::ensure_dir_exists("component", p, &|_: Notification<'_>| ())?;
+                utils::ensure_dir_exists("component", p)?;
             }
             Ok(abs_path)
         }
@@ -354,7 +354,7 @@ impl<'a> ChangedItem<'a> {
             Ok(ChangedItem::ModifiedFile(relpath, Some(backup)))
         } else {
             if let Some(p) = abs_path.parent() {
-                utils::ensure_dir_exists("component", p, &|_: Notification<'_>| {})?;
+                utils::ensure_dir_exists("component", p)?;
             }
             Ok(ChangedItem::ModifiedFile(relpath, None))
         }

src/dist/download.rs

@@ -43,11 +43,7 @@ impl<'a> DownloadCfg<'a> {
     /// target file already exists, then the hash is checked and it is returned
     /// immediately without re-downloading.
     pub(crate) async fn download(&self, url: &Url, hash: &str) -> Result<File> {
-        utils::ensure_dir_exists(
-            "Download Directory",
-            self.download_dir,
-            &self.notify_handler,
-        )?;
+        utils::ensure_dir_exists("Download Directory", self.download_dir)?;
         let target_file = self.download_dir.join(Path::new(hash));
 
         if target_file.exists() {

src/dist/manifestation/tests.rs

@@ -1471,12 +1471,7 @@ async fn unable_to_download_component() {
 }
 
 fn prevent_installation(prefix: &InstallPrefix) {
-    utils::ensure_dir_exists(
-        "installation path",
-        &prefix.path().join("lib"),
-        &|_: Notification<'_>| {},
-    )
-    .unwrap();
+    utils::ensure_dir_exists("installation path", &prefix.path().join("lib")).unwrap();
     let install_blocker = prefix.path().join("lib").join("rustlib");
     utils::write_file("install-blocker", &install_blocker, "fail-installation").unwrap();
 }
@@ -1526,7 +1521,7 @@ async fn checks_files_hashes_before_reuse() {
     .unwrap()[..64]
         .to_owned();
     let prev_download = cx.download_dir.join(target_hash);
-    utils::ensure_dir_exists("download dir", &cx.download_dir, &|_: Notification<'_>| {}).unwrap();
+    utils::ensure_dir_exists("download dir", &cx.download_dir).unwrap();
     utils::write_file("bad previous download", &prev_download, "bad content").unwrap();
     println!("wrote previous download to {}", prev_download.display());
 
@@ -1560,7 +1555,7 @@ async fn handle_corrupt_partial_downloads() {
     .unwrap()[..SHA256_HASH_LEN]
         .to_owned();
 
-    utils::ensure_dir_exists("download dir", &cx.download_dir, &|_: Notification<'_>| {}).unwrap();
+    utils::ensure_dir_exists("download dir", &cx.download_dir).unwrap();
     let partial_path = cx.download_dir.join(format!("{target_hash}.partial"));
     utils_raw::write_file(
         &partial_path,

src/dist/temp.rs

@@ -3,6 +3,7 @@ use std::{fmt, fs, ops};
 
 pub(crate) use anyhow::{Context as _, Result};
 use thiserror::Error as ThisError;
+use tracing::debug;
 
 use crate::notifications::Notification;
 use crate::utils::{self, raw};
@@ -103,7 +104,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", &temp_dir));
+                debug!(name = "temp", path = %temp_dir.display(), "creating directory");
                 fs::create_dir(&temp_dir)
                     .with_context(|| CreatingError::Directory(PathBuf::from(&temp_dir)))?;
                 return Ok(Dir {

src/notifications.rs

@@ -37,7 +37,6 @@ pub enum Notification<'a> {
     StrayHash(&'a Path),
     SignatureInvalid(&'a str),
     RetryingDownload(&'a str),
-    CreatingDirectory(&'a str, &'a Path),
     LinkingDirectory(&'a Path, &'a Path),
     CopyingDirectory(&'a Path, &'a Path),
     RemovingDirectory(&'a str, &'a Path),
@@ -124,8 +123,7 @@ impl Notification<'_> {
             NonFatalError(_) => NotificationLevel::Error,
             SignatureInvalid(_) => NotificationLevel::Warn,
             SetDefaultBufferSize(_) => NotificationLevel::Trace,
-            CreatingDirectory(_, _)
-            | RemovingDirectory(_, _)
+            RemovingDirectory(_, _)
             | LinkingDirectory(_, _)
             | CopyingDirectory(_, _)
             | DownloadingFile(_, _)
@@ -261,9 +259,6 @@ impl Display for Notification<'_> {
             }
             SignatureInvalid(url) => write!(f, "Signature verification failed for '{url}'"),
             RetryingDownload(url) => write!(f, "retrying download for '{url}'"),
-            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()),

src/utils/mod.rs

@@ -11,6 +11,7 @@ use std::process::ExitStatus;
 use anyhow::{Context, Result, anyhow, bail};
 use retry::delay::{Fibonacci, jitter};
 use retry::{OperationResult, retry};
+use tracing::debug;
 use url::Url;
 
 use crate::errors::*;
@@ -60,16 +61,9 @@ impl From<ExitStatus> for ExitCode {
     }
 }
 
-pub fn ensure_dir_exists<'a, N>(
-    name: &'static str,
-    path: &'a Path,
-    notify_handler: &'a dyn Fn(N),
-) -> Result<bool>
-where
-    N: From<Notification<'a>>,
-{
+pub fn ensure_dir_exists(name: &'static str, path: &Path) -> Result<bool> {
     raw::ensure_dir_exists(path, |_| {
-        notify_handler(Notification::CreatingDirectory(name, path).into())
+        debug!(name, path = %path.display(), "creating directory");
     })
     .with_context(|| RustupError::CreatingDirectory {
         name,