feat(downloads): refactor for allowing installations to happen on a separate thread

Co-authored-by: FranciscoTGouveia
<francisco.t.gouveia@tecnico.ulisboa.pt>

Author: rami3l

src/cli/common.rs

@@ -1,13 +1,12 @@
 //! Just a dumping ground for cli stuff
 
-use std::cell::RefCell;
 use std::fmt::Display;
 use std::fs;
 #[cfg(not(windows))]
 use std::io::ErrorKind;
 use std::io::{BufRead, Write};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, LazyLock, Mutex};
+use std::sync::{Arc, LazyLock, Mutex, RwLock};
 use std::{cmp, env};
 
 use anyhow::{Context, Result, anyhow};
@@ -126,14 +125,14 @@ pub(crate) fn read_line(process: &Process) -> Result<String> {
 
 pub(super) struct Notifier {
     tracker: Mutex<DownloadTracker>,
-    ram_notice_shown: RefCell<bool>,
+    ram_notice_shown: RwLock<bool>,
 }
 
 impl Notifier {
     pub(super) fn new(quiet: bool, process: &Process) -> Self {
         Self {
             tracker: Mutex::new(DownloadTracker::new_with_display_progress(!quiet, process)),
-            ram_notice_shown: RefCell::new(false),
+            ram_notice_shown: RwLock::new(false),
         }
     }
 
@@ -146,10 +145,10 @@ impl Notifier {
             util_notifications::Notification::SetDefaultBufferSize(_),
         )) = &n
         {
-            if *self.ram_notice_shown.borrow() {
+            if *self.ram_notice_shown.read().unwrap() {
                 return;
             } else {
-                *self.ram_notice_shown.borrow_mut() = true;
+                *self.ram_notice_shown.write().unwrap() = true;
             }
         };
         let level = n.level();

src/config.rs

@@ -233,15 +233,15 @@ pub(crate) struct Cfg<'a> {
     pub toolchain_override: Option<ResolvableToolchainName>,
     pub env_override: Option<LocalToolchainName>,
     pub dist_root_url: String,
-    pub notify_handler: Arc<dyn Fn(Notification<'_>)>,
+    pub notify_handler: Arc<NotifyHandler>,
     pub current_dir: PathBuf,
     pub process: &'a Process,
 }
 
 impl<'a> Cfg<'a> {
     pub(crate) fn from_env(
         current_dir: PathBuf,
-        notify_handler: Arc<dyn Fn(Notification<'_>)>,
+        notify_handler: Arc<NotifyHandler>,
         process: &'a Process,
     ) -> Result<Self> {
         // Set up the rustup home directory
@@ -295,7 +295,7 @@ impl<'a> Cfg<'a> {
         let tmp_cx = temp::Context::new(
             rustup_dir.join("tmp"),
             dist_root_server.as_str(),
-            Box::new(move |n| (notify_clone)(n.into())),
+            Arc::new(move |n| (notify_clone)(n.into())),
         );
         let dist_root = dist_root_server + "/dist";
 
@@ -330,13 +330,13 @@ impl<'a> Cfg<'a> {
     /// construct a download configuration
     pub(crate) fn download_cfg(
         &'a self,
-        notify_handler: &'a dyn Fn(crate::dist::Notification<'_>),
+        notify_handler: Arc<dist::notifications::NotifyHandler>,
     ) -> DownloadCfg<'a> {
         DownloadCfg {
             dist_root: &self.dist_root_url,
-            tmp_cx: &self.tmp_cx,
+            tmp_cx: Arc::new(self.tmp_cx.clone()),
             download_dir: &self.download_dir,
-            notify_handler,
+            notify_handler: Arc::clone(&notify_handler),
             process: self.process,
         }
     }

src/dist/component/components.rs

@@ -55,7 +55,7 @@ impl Components {
             Ok(None)
         }
     }
-    fn write_version(&self, tx: &mut Transaction<'_>) -> Result<()> {
+    fn write_version(&self, tx: &mut Transaction) -> Result<()> {
         tx.modify_file(self.prefix.rel_manifest_file(VERSION_FILE))?;
         utils::write_file(
             VERSION_FILE,
@@ -79,7 +79,7 @@ impl Components {
             })
             .collect())
     }
-    pub(crate) fn add<'a>(&self, name: &str, tx: Transaction<'a>) -> ComponentBuilder<'a> {
+    pub(crate) fn add(&self, name: &str, tx: Transaction) -> ComponentBuilder {
         ComponentBuilder {
             components: self.clone(),
             name: name.to_owned(),
@@ -96,14 +96,14 @@ impl Components {
     }
 }
 
-pub(crate) struct ComponentBuilder<'a> {
+pub(crate) struct ComponentBuilder {
     components: Components,
     name: String,
     parts: Vec<ComponentPart>,
-    tx: Transaction<'a>,
+    tx: Transaction,
 }
 
-impl<'a> ComponentBuilder<'a> {
+impl ComponentBuilder {
     pub(crate) fn copy_file(&mut self, path: PathBuf, src: &Path) -> Result<()> {
         self.parts.push(ComponentPart {
             kind: ComponentPartKind::File,
@@ -132,7 +132,7 @@ impl<'a> ComponentBuilder<'a> {
         });
         self.tx.move_dir(&self.name, path, src)
     }
-    pub(crate) fn finish(mut self) -> Result<Transaction<'a>> {
+    pub(crate) fn finish(mut self) -> Result<Transaction> {
         // Write component manifest
         let path = self.components.rel_component_manifest(&self.name);
         let abs_path = self.components.prefix.abs_path(&path);
@@ -255,18 +255,20 @@ impl Component {
         }
         Ok(result)
     }
-    pub fn uninstall<'a>(
-        &self,
-        mut tx: Transaction<'a>,
-        process: &Process,
-    ) -> Result<Transaction<'a>> {
+    pub fn uninstall(&self, mut tx: Transaction, process: &Process) -> Result<Transaction> {
         // Update components file
         let path = self.components.rel_components_file();
         let abs_path = self.components.prefix.abs_path(&path);
         let temp = tx.temp().new_file()?;
         utils::filter_file("components", &abs_path, &temp, |l| l != self.name)?;
         tx.modify_file(path)?;
-        utils::rename("components", &temp, &abs_path, tx.notify_handler(), process)?;
+        utils::rename(
+            "components",
+            &temp,
+            &abs_path,
+            &*tx.notify_handler(),
+            process,
+        )?;
 
         // TODO: If this is the last component remove the components file
         // and the version file.

src/dist/component/package.rs

@@ -7,6 +7,7 @@ use std::fmt;
 use std::io::{self, ErrorKind as IOErrorKind, Read};
 use std::mem;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::{Context, Result, anyhow, bail};
 use tar::EntryType;
@@ -26,13 +27,13 @@ pub(crate) const VERSION_FILE: &str = "rust-installer-version";
 
 pub trait Package: fmt::Debug {
     fn contains(&self, component: &str, short_name: Option<&str>) -> bool;
-    fn install<'a>(
+    fn install(
         &self,
         target: &Components,
         component: &str,
         short_name: Option<&str>,
-        tx: Transaction<'a>,
-    ) -> Result<Transaction<'a>>;
+        tx: Transaction,
+    ) -> Result<Transaction>;
     fn components(&self) -> Vec<String>;
 }
 
@@ -79,13 +80,13 @@ impl Package for DirectoryPackage {
                 false
             }
     }
-    fn install<'a>(
+    fn install(
         &self,
         target: &Components,
         name: &str,
         short_name: Option<&str>,
-        tx: Transaction<'a>,
-    ) -> Result<Transaction<'a>> {
+        tx: Transaction,
+    ) -> Result<Transaction> {
         let actual_name = if self.components.contains(name) {
             name
         } else if let Some(n) = short_name {
@@ -137,13 +138,13 @@ impl Package for DirectoryPackage {
 
 #[derive(Debug)]
 #[allow(dead_code)] // temp::Dir is held for drop.
-pub(crate) struct TarPackage<'a>(DirectoryPackage, temp::Dir<'a>);
+pub(crate) struct TarPackage(DirectoryPackage, temp::Dir);
 
-impl<'a> TarPackage<'a> {
+impl TarPackage {
     pub(crate) fn new<R: Read>(
         stream: R,
-        tmp_cx: &'a temp::Context,
-        notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
+        tmp_cx: Arc<temp::Context>,
+        notify_handler: Option<&dyn Fn(Notification<'_>)>,
         process: &Process,
     ) -> Result<Self> {
         let temp_dir = tmp_cx.new_directory()?;
@@ -532,17 +533,17 @@ fn unpack_without_first_dir<R: Read>(
     Ok(())
 }
 
-impl Package for TarPackage<'_> {
+impl Package for TarPackage {
     fn contains(&self, component: &str, short_name: Option<&str>) -> bool {
         self.0.contains(component, short_name)
     }
-    fn install<'b>(
+    fn install(
         &self,
         target: &Components,
         component: &str,
         short_name: Option<&str>,
-        tx: Transaction<'b>,
-    ) -> Result<Transaction<'b>> {
+        tx: Transaction,
+    ) -> Result<Transaction> {
         self.0.install(target, component, short_name, tx)
     }
     fn components(&self) -> Vec<String> {
@@ -551,36 +552,36 @@ impl Package for TarPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarGzPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarGzPackage(TarPackage);
 
-impl<'a> TarGzPackage<'a> {
+impl TarGzPackage {
     pub(crate) fn new<R: Read>(
         stream: R,
-        tmp_cx: &'a temp::Context,
-        notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
+        tmp_cx: Arc<temp::Context>,
+        notify_handler: Option<&dyn Fn(Notification<'_>)>,
         process: &Process,
     ) -> Result<Self> {
         let stream = flate2::read::GzDecoder::new(stream);
         Ok(TarGzPackage(TarPackage::new(
             stream,
-            tmp_cx,
+            Arc::clone(&tmp_cx),
             notify_handler,
             process,
         )?))
     }
 }
 
-impl Package for TarGzPackage<'_> {
+impl Package for TarGzPackage {
     fn contains(&self, component: &str, short_name: Option<&str>) -> bool {
         self.0.contains(component, short_name)
     }
-    fn install<'b>(
+    fn install(
         &self,
         target: &Components,
         component: &str,
         short_name: Option<&str>,
-        tx: Transaction<'b>,
-    ) -> Result<Transaction<'b>> {
+        tx: Transaction,
+    ) -> Result<Transaction> {
         self.0.install(target, component, short_name, tx)
     }
     fn components(&self) -> Vec<String> {
@@ -589,36 +590,36 @@ impl Package for TarGzPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarXzPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarXzPackage(TarPackage);
 
-impl<'a> TarXzPackage<'a> {
+impl TarXzPackage {
     pub(crate) fn new<R: Read>(
         stream: R,
-        tmp_cx: &'a temp::Context,
-        notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
+        tmp_cx: Arc<temp::Context>,
+        notify_handler: Option<&dyn Fn(Notification<'_>)>,
         process: &Process,
     ) -> Result<Self> {
         let stream = xz2::read::XzDecoder::new(stream);
         Ok(TarXzPackage(TarPackage::new(
             stream,
-            tmp_cx,
+            Arc::clone(&tmp_cx),
             notify_handler,
             process,
         )?))
     }
 }
 
-impl Package for TarXzPackage<'_> {
+impl Package for TarXzPackage {
     fn contains(&self, component: &str, short_name: Option<&str>) -> bool {
         self.0.contains(component, short_name)
     }
-    fn install<'b>(
+    fn install(
         &self,
         target: &Components,
         component: &str,
         short_name: Option<&str>,
-        tx: Transaction<'b>,
-    ) -> Result<Transaction<'b>> {
+        tx: Transaction,
+    ) -> Result<Transaction> {
         self.0.install(target, component, short_name, tx)
     }
     fn components(&self) -> Vec<String> {
@@ -627,36 +628,36 @@ impl Package for TarXzPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarZStdPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarZStdPackage(TarPackage);
 
-impl<'a> TarZStdPackage<'a> {
+impl TarZStdPackage {
     pub(crate) fn new<R: Read>(
         stream: R,
-        tmp_cx: &'a temp::Context,
-        notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
+        tmp_cx: Arc<temp::Context>,
+        notify_handler: Option<&dyn Fn(Notification<'_>)>,
         process: &Process,
     ) -> Result<Self> {
         let stream = zstd::stream::read::Decoder::new(stream)?;
         Ok(TarZStdPackage(TarPackage::new(
             stream,
-            tmp_cx,
+            Arc::clone(&tmp_cx),
             notify_handler,
             process,
         )?))
     }
 }
 
-impl Package for TarZStdPackage<'_> {
+impl Package for TarZStdPackage {
     fn contains(&self, component: &str, short_name: Option<&str>) -> bool {
         self.0.contains(component, short_name)
     }
-    fn install<'b>(
+    fn install(
         &self,
         target: &Components,
         component: &str,
         short_name: Option<&str>,
-        tx: Transaction<'b>,
-    ) -> Result<Transaction<'b>> {
+        tx: Transaction,
+    ) -> Result<Transaction> {
         self.0.install(target, component, short_name, tx)
     }
     fn components(&self) -> Vec<String> {