Use lock

Signed-off-by: hi-rustin <rustin.liu@gmail.com>

Author: 0xPoe

src/cli/common.rs

@@ -26,7 +26,7 @@ use crate::{Cfg, Notification};
 pub(crate) const WARN_COMPLETE_PROFILE: &str = "downloading with complete profile isn't recommended unless you are a developer of the rust language";
 
 pub(crate) fn confirm(question: &str, default: bool) -> Result<bool> {
-    write!(process().stdout(), "{question} ")?;
+    write!(process().stdout().lock(), "{question} ")?;
     let _ = std::io::stdout().flush();
     let input = read_line()?;
 
@@ -37,7 +37,7 @@ pub(crate) fn confirm(question: &str, default: bool) -> Result<bool> {
         _ => false,
     };
 
-    writeln!(process().stdout())?;
+    writeln!(process().stdout().lock())?;
 
     Ok(r)
 }
@@ -49,11 +49,14 @@ pub(crate) enum Confirm {
 }
 
 pub(crate) fn confirm_advanced() -> Result<Confirm> {
-    writeln!(process().stdout())?;
-    writeln!(process().stdout(), "1) Proceed with installation (default)")?;
-    writeln!(process().stdout(), "2) Customize installation")?;
-    writeln!(process().stdout(), "3) Cancel installation")?;
-    write!(process().stdout(), ">")?;
+    writeln!(process().stdout().lock())?;
+    writeln!(
+        process().stdout().lock(),
+        "1) Proceed with installation (default)"
+    )?;
+    writeln!(process().stdout().lock(), "2) Customize installation")?;
+    writeln!(process().stdout().lock(), "3) Cancel installation")?;
+    write!(process().stdout().lock(), ">")?;
 
     let _ = std::io::stdout().flush();
     let input = read_line()?;
@@ -64,17 +67,17 @@ pub(crate) fn confirm_advanced() -> Result<Confirm> {
         _ => Confirm::No,
     };
 
-    writeln!(process().stdout())?;
+    writeln!(process().stdout().lock())?;
 
     Ok(r)
 }
 
 pub(crate) fn question_str(question: &str, default: &str) -> Result<String> {
-    writeln!(process().stdout(), "{question} [{default}]")?;
+    writeln!(process().stdout().lock(), "{question} [{default}]")?;
     let _ = std::io::stdout().flush();
     let input = read_line()?;
 
-    writeln!(process().stdout())?;
+    writeln!(process().stdout().lock())?;
 
     if input.is_empty() {
         Ok(default.to_string())
@@ -85,12 +88,12 @@ pub(crate) fn question_str(question: &str, default: &str) -> Result<String> {
 
 pub(crate) fn question_bool(question: &str, default: bool) -> Result<bool> {
     let default_text = if default { "(Y/n)" } else { "(y/N)" };
-    writeln!(process().stdout(), "{question} {default_text}")?;
+    writeln!(process().stdout().lock(), "{question} {default_text}")?;
 
     let _ = std::io::stdout().flush();
     let input = read_line()?;
 
-    writeln!(process().stdout())?;
+    writeln!(process().stdout().lock())?;
 
     if input.is_empty() {
         Ok(default)
@@ -257,20 +260,20 @@ fn show_channel_updates(
     for (pkg, banner, width, color, version, previous_version) in data {
         let padding = max_width - width;
         let padding: String = " ".repeat(padding);
-        let _ = write!(t, "  {padding}");
+        let _ = write!(t.lock(), "  {padding}");
         let _ = t.attr(term::Attr::Bold);
         if let Some(color) = color {
             let _ = t.fg(color);
         }
-        let _ = write!(t, "{pkg} {banner}");
+        let _ = write!(t.lock(), "{pkg} {banner}");
         let _ = t.reset();
-        let _ = write!(t, " - {version}");
+        let _ = write!(t.lock(), " - {version}");
         if let Some(previous_version) = previous_version {
-            let _ = write!(t, " (from {previous_version})");
+            let _ = write!(t.lock(), " (from {previous_version})");
         }
-        let _ = writeln!(t);
+        let _ = writeln!(t.lock());
     }
-    let _ = writeln!(t);
+    let _ = writeln!(t.lock());
 
     Ok(())
 }
@@ -288,7 +291,7 @@ pub(crate) fn update_all_channels(
 
     let show_channel_updates = || {
         if !toolchains.is_empty() {
-            writeln!(process().stdout())?;
+            writeln!(process().stdout().lock())?;
 
             let t = toolchains
                 .into_iter()
@@ -382,10 +385,10 @@ pub(crate) fn list_targets(distributable: DistributableToolchain<'_>) -> Result<
                 .expect("rust-std should have a target");
             if component.installed {
                 let _ = t.attr(term::Attr::Bold);
-                let _ = writeln!(t, "{target} (installed)");
+                let _ = writeln!(t.lock(), "{target} (installed)");
                 let _ = t.reset();
             } else if component.available {
-                let _ = writeln!(t, "{target}");
+                let _ = writeln!(t.lock(), "{target}");
             }
         }
     }
@@ -396,7 +399,9 @@ pub(crate) fn list_targets(distributable: DistributableToolchain<'_>) -> Result<
 pub(crate) fn list_installed_targets(
     distributable: DistributableToolchain<'_>,
 ) -> Result<utils::ExitCode> {
-    let mut t = term::stdout();
+    let t = term::stdout();
+    let mut t_lock = t.lock();
+
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
@@ -409,7 +414,7 @@ pub(crate) fn list_installed_targets(
                 .as_ref()
                 .expect("rust-std should have a target");
             if component.installed {
-                writeln!(t, "{target}")?;
+                writeln!(t_lock, "{target}")?;
             }
         }
     }
@@ -420,6 +425,7 @@ pub(crate) fn list_components(
     distributable: DistributableToolchain<'_>,
 ) -> Result<utils::ExitCode> {
     let mut t = term::stdout();
+
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
@@ -428,26 +434,26 @@ pub(crate) fn list_components(
         let name = component.name;
         if component.installed {
             t.attr(term::Attr::Bold)?;
-            writeln!(t, "{name} (installed)")?;
+            writeln!(t.lock(), "{name} (installed)")?;
             t.reset()?;
         } else if component.available {
-            writeln!(t, "{name}")?;
+            writeln!(t.lock(), "{name}")?;
         }
     }
 
     Ok(utils::ExitCode(0))
 }
 
 pub(crate) fn list_installed_components(distributable: DistributableToolchain<'_>) -> Result<()> {
-    let mut t = term::stdout();
+    let t = term::stdout();
     let manifestation = distributable.get_manifestation()?;
     let config = manifestation.read_config()?.unwrap_or_default();
     let manifest = distributable.get_manifest()?;
     let components = manifest.query_components(distributable.desc(), &config)?;
 
     for component in components {
         if component.installed {
-            writeln!(t, "{}", component.name)?;
+            writeln!(t.lock(), "{}", component.name)?;
         }
     }
     Ok(())
@@ -472,7 +478,7 @@ fn print_toolchain_path(
         String::new()
     };
     writeln!(
-        process().stdout(),
+        process().stdout().lock(),
         "{}{}{}{}",
         &toolchain,
         if_default,
@@ -490,7 +496,7 @@ pub(crate) fn list_toolchains(cfg: &Cfg, verbose: bool) -> Result<utils::ExitCod
         .map(Into::into)
         .collect::<Vec<_>>();
     if toolchains.is_empty() {
-        writeln!(process().stdout(), "no installed toolchains")?;
+        writeln!(process().stdout().lock(), "no installed toolchains")?;
     } else {
         let def_toolchain_name = cfg.get_default()?.map(|t| (&t).into());
         let cwd = utils::current_dir()?;
@@ -528,7 +534,7 @@ pub(crate) fn list_overrides(cfg: &Cfg) -> Result<utils::ExitCode> {
     let overrides = cfg.settings_file.with(|s| Ok(s.overrides.clone()))?;
 
     if overrides.is_empty() {
-        writeln!(process().stdout(), "no overrides")?;
+        writeln!(process().stdout().lock(), "no overrides")?;
     } else {
         let mut any_not_exist = false;
         for (k, v) in overrides {
@@ -537,15 +543,15 @@ pub(crate) fn list_overrides(cfg: &Cfg) -> Result<utils::ExitCode> {
                 any_not_exist = true;
             }
             writeln!(
-                process().stdout(),
+                process().stdout().lock(),
                 "{:<40}\t{:<20}",
                 utils::format_path_for_display(&k)
                     + if dir_exists { "" } else { " (not a directory)" },
                 v
             )?
         }
         if any_not_exist {
-            writeln!(process().stdout())?;
+            writeln!(process().stdout().lock())?;
             info!(
                 "you may remove overrides for non-existent directories with
 `rustup override unset --nonexistent`"
@@ -570,43 +576,51 @@ pub(crate) fn version() -> &'static str {
 pub(crate) fn dump_testament() -> Result<utils::ExitCode> {
     use git_testament::GitModification::*;
     writeln!(
-        process().stdout(),
+        process().stdout().lock(),
         "Rustup version renders as: {}",
         version()
     )?;
     writeln!(
-        process().stdout(),
+        process().stdout().lock(),
         "Current crate version: {}",
         env!("CARGO_PKG_VERSION")
     )?;
     if TESTAMENT.branch_name.is_some() {
         writeln!(
-            process().stdout(),
+            process().stdout().lock(),
             "Built from branch: {}",
             TESTAMENT.branch_name.unwrap()
         )?;
     } else {
-        writeln!(process().stdout(), "Branch information missing")?;
+        writeln!(process().stdout().lock(), "Branch information missing")?;
     }
-    writeln!(process().stdout(), "Commit info: {}", TESTAMENT.commit)?;
+    writeln!(
+        process().stdout().lock(),
+        "Commit info: {}",
+        TESTAMENT.commit
+    )?;
     if TESTAMENT.modifications.is_empty() {
-        writeln!(process().stdout(), "Working tree is clean")?;
+        writeln!(process().stdout().lock(), "Working tree is clean")?;
     } else {
         for fmod in TESTAMENT.modifications {
             match fmod {
-                Added(f) => writeln!(process().stdout(), "Added: {}", String::from_utf8_lossy(f))?,
+                Added(f) => writeln!(
+                    process().stdout().lock(),
+                    "Added: {}",
+                    String::from_utf8_lossy(f)
+                )?,
                 Removed(f) => writeln!(
-                    process().stdout(),
+                    process().stdout().lock(),
                     "Removed: {}",
                     String::from_utf8_lossy(f)
                 )?,
                 Modified(f) => writeln!(
-                    process().stdout(),
+                    process().stdout().lock(),
                     "Modified: {}",
                     String::from_utf8_lossy(f)
                 )?,
                 Untracked(f) => writeln!(
-                    process().stdout(),
+                    process().stdout().lock(),
                     "Untracked: {}",
                     String::from_utf8_lossy(f)
                 )?,

src/cli/download_tracker.rs

@@ -132,7 +132,7 @@ impl DownloadTracker {
         if self.displayed_charcount.is_some() {
             // Display the finished state
             self.display();
-            let _ = writeln!(self.term);
+            let _ = writeln!(self.term.lock());
         }
         self.prepare_for_new_download();
     }
@@ -171,8 +171,8 @@ impl DownloadTracker {
                     // This is not ideal as very narrow terminals might mess up,
                     // but it is more likely to succeed until term's windows console
                     // fixes whatever's up with delete_line().
-                    let _ = write!(self.term, "{}", " ".repeat(n));
-                    let _ = self.term.flush();
+                    let _ = write!(self.term.lock(), "{}", " ".repeat(n));
+                    let _ = self.term.lock().flush();
                     let _ = self.term.carriage_return();
                 }
 
@@ -204,9 +204,9 @@ impl DownloadTracker {
                     ),
                 };
 
-                let _ = write!(self.term, "{output}");
+                let _ = write!(self.term.lock(), "{output}");
                 // Since stdout is typically line-buffered and we don't print a newline, we manually flush.
-                let _ = self.term.flush();
+                let _ = self.term.lock().flush();
                 self.displayed_charcount = Some(output.chars().count());
             }
         }

src/cli/log.rs

@@ -26,49 +26,49 @@ pub(crate) fn warn_fmt(args: fmt::Arguments<'_>) {
     let mut t = term::stderr();
     let _ = t.fg(term::Color::Yellow);
     let _ = t.attr(term::Attr::Bold);
-    let _ = write!(t, "warning: ");
+    let _ = write!(t.lock(), "warning: ");
     let _ = t.reset();
-    let _ = t.write_fmt(args);
-    let _ = writeln!(t);
+    let _ = t.lock().write_fmt(args);
+    let _ = writeln!(t.lock());
 }
 
 pub(crate) fn err_fmt(args: fmt::Arguments<'_>) {
     let mut t = term::stderr();
     let _ = t.fg(term::Color::Red);
     let _ = t.attr(term::Attr::Bold);
-    let _ = write!(t, "error: ");
+    let _ = write!(t.lock(), "error: ");
     let _ = t.reset();
-    let _ = t.write_fmt(args);
-    let _ = writeln!(t);
+    let _ = t.lock().write_fmt(args);
+    let _ = writeln!(t.lock());
 }
 
 pub(crate) fn info_fmt(args: fmt::Arguments<'_>) {
     let mut t = term::stderr();
     let _ = t.attr(term::Attr::Bold);
-    let _ = write!(t, "info: ");
+    let _ = write!(t.lock(), "info: ");
     let _ = t.reset();
-    let _ = t.write_fmt(args);
-    let _ = writeln!(t);
+    let _ = t.lock().write_fmt(args);
+    let _ = writeln!(t.lock());
 }
 
 pub(crate) fn verbose_fmt(args: fmt::Arguments<'_>) {
     let mut t = term::stderr();
     let _ = t.fg(term::Color::Magenta);
     let _ = t.attr(term::Attr::Bold);
-    let _ = write!(t, "verbose: ");
+    let _ = write!(t.lock(), "verbose: ");
     let _ = t.reset();
-    let _ = t.write_fmt(args);
-    let _ = writeln!(t);
+    let _ = t.lock().write_fmt(args);
+    let _ = writeln!(t.lock());
 }
 
 pub(crate) fn debug_fmt(args: fmt::Arguments<'_>) {
     if process().var("RUSTUP_DEBUG").is_ok() {
         let mut t = term::stderr();
         let _ = t.fg(term::Color::Blue);
         let _ = t.attr(term::Attr::Bold);
-        let _ = write!(t, "debug: ");
+        let _ = write!(t.lock(), "debug: ");
         let _ = t.reset();
-        let _ = t.write_fmt(args);
-        let _ = writeln!(t);
+        let _ = t.lock().write_fmt(args);
+        let _ = writeln!(t.lock());
     }
 }