refactor(downloads): remove some lifetime parameters to allow multi-thread installations

Co-authored-by: rami3l <[email protected]>

Author: FranciscoTGouveia

src/config.rs

@@ -229,19 +229,19 @@ pub(crate) struct Cfg<'a> {
     pub toolchains_dir: PathBuf,
     pub update_hash_dir: PathBuf,
     pub download_dir: PathBuf,
-    pub tmp_cx: temp::Context,
+    pub tmp_cx: Arc<temp::Context>,
     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
@@ -292,11 +292,11 @@ impl<'a> Cfg<'a> {
         let dist_root_server = dist_root_server(process)?;
 
         let notify_clone = notify_handler.clone();
-        let tmp_cx = temp::Context::new(
+        let tmp_cx = Arc::new(temp::Context::new(
             rustup_dir.join("tmp"),
             dist_root_server.as_str(),
-            Box::new(move |n| (notify_clone)(n)),
-        );
+            Arc::new(move |n| (notify_clone)(n)),
+        ));
         let dist_root = dist_root_server + "/dist";
 
         let cfg = Self {
@@ -329,15 +329,15 @@ impl<'a> Cfg<'a> {
 
     /// construct a download configuration
     pub(crate) fn download_cfg(
-        &'a self,
-        notify_handler: &'a dyn Fn(Notification<'_>),
-    ) -> DownloadCfg<'a> {
+        &self,
+        notify_handler: Arc<NotifyHandler>,
+    ) -> DownloadCfg {
         DownloadCfg {
-            dist_root: &self.dist_root_url,
-            tmp_cx: &self.tmp_cx,
-            download_dir: &self.download_dir,
+            dist_root: Arc::from(self.dist_root_url.clone()),
+            tmp_cx: Arc::clone(&self.tmp_cx),
+            download_dir: Arc::new(self.download_dir.clone()),
             notify_handler,
-            process: self.process,
+            process: Arc::new(self.process.clone()),
         }
     }
 

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;
@@ -27,13 +28,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>;
 }
 
@@ -80,13 +81,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 {
@@ -138,11 +139,12 @@ 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> {
-    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext<'a>) -> Result<Self> {
-        let temp_dir = cx.tmp_cx.new_directory()?;
+impl TarPackage {
+    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext) -> Result<Self> {
+        let ctx = cx.tmp_cx.clone();
+        let temp_dir = ctx.new_directory()?;
         let mut archive = tar::Archive::new(stream);
         // The rust-installer packages unpack to a directory called
         // $pkgname-$version-$target. Skip that directory when
@@ -161,7 +163,7 @@ impl<'a> TarPackage<'a> {
 fn unpack_ram(
     io_chunk_size: usize,
     effective_max_ram: Option<usize>,
-    cx: &PackageContext<'_>,
+    cx: &PackageContext,
 ) -> usize {
     const RAM_ALLOWANCE_FOR_RUSTUP_AND_BUFFERS: usize = 200 * 1024 * 1024;
     let minimum_ram = io_chunk_size * 2;
@@ -199,7 +201,7 @@ fn unpack_ram(
             }
         }
         None => {
-            if let Some(h) = cx.notify_handler {
+            if let Some(h) = &cx.notify_handler {
                 h(Notification::SetDefaultBufferSize(default_max_unpack_ram))
             }
             default_max_unpack_ram
@@ -285,21 +287,22 @@ enum DirStatus {
 fn unpack_without_first_dir<R: Read>(
     archive: &mut tar::Archive<R>,
     path: &Path,
-    cx: &PackageContext<'_>,
+    cx: &PackageContext,
 ) -> Result<()> {
     let entries = archive.entries()?;
     let effective_max_ram = match effective_limits::memory_limit() {
         Ok(ram) => Some(ram as usize),
         Err(e) => {
-            if let Some(h) = cx.notify_handler {
+            if let Some(h) = &cx.notify_handler {
                 h(Notification::Error(e.to_string()))
             }
             None
         }
     };
     let unpack_ram = unpack_ram(IO_CHUNK_SIZE, effective_max_ram, cx);
+    let handler_ref = cx.notify_handler.as_ref().map(|h| h.as_ref());
     let mut io_executor: Box<dyn Executor> =
-        get_executor(cx.notify_handler, unpack_ram, cx.process)?;
+        get_executor(handler_ref, unpack_ram, &cx.process)?;
 
     let mut directories: HashMap<PathBuf, DirStatus> = HashMap::new();
     // Path is presumed to exist. Call it a precondition.
@@ -528,17 +531,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> {
@@ -547,26 +550,26 @@ impl Package for TarPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarGzPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarGzPackage(TarPackage);
 
-impl<'a> TarGzPackage<'a> {
-    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext<'a>) -> Result<Self> {
+impl TarGzPackage {
+    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext) -> Result<Self> {
         let stream = flate2::read::GzDecoder::new(stream);
         Ok(TarGzPackage(TarPackage::new(stream, cx)?))
     }
 }
 
-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> {
@@ -575,26 +578,26 @@ impl Package for TarGzPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarXzPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarXzPackage(TarPackage);
 
-impl<'a> TarXzPackage<'a> {
-    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext<'a>) -> Result<Self> {
+impl TarXzPackage {
+    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext) -> Result<Self> {
         let stream = xz2::read::XzDecoder::new(stream);
         Ok(TarXzPackage(TarPackage::new(stream, cx)?))
     }
 }
 
-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> {
@@ -603,35 +606,35 @@ impl Package for TarXzPackage<'_> {
 }
 
 #[derive(Debug)]
-pub(crate) struct TarZStdPackage<'a>(TarPackage<'a>);
+pub(crate) struct TarZStdPackage(TarPackage);
 
-impl<'a> TarZStdPackage<'a> {
-    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext<'a>) -> Result<Self> {
+impl TarZStdPackage {
+    pub(crate) fn new<R: Read>(stream: R, cx: &PackageContext) -> Result<Self> {
         let stream = zstd::stream::read::Decoder::new(stream)?;
         Ok(TarZStdPackage(TarPackage::new(stream, cx)?))
     }
 }
 
-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> {
         self.0.components()
     }
 }
 
-pub(crate) struct PackageContext<'a> {
-    pub(crate) tmp_cx: &'a temp::Context,
-    pub(crate) notify_handler: Option<&'a dyn Fn(Notification<'_>)>,
-    pub(crate) process: &'a Process,
+pub(crate) struct PackageContext {
+    pub(crate) tmp_cx: Arc<temp::Context>,
+    pub(crate) notify_handler: Option<Arc<dyn Fn(Notification<'_>)>>,
+    pub(crate) process: Arc<Process>,
 }