Make Sysroot::install async

So that we can call it from async functions.

Author: Kobzol

collector/src/bin/collector.rs

@@ -1055,7 +1055,8 @@ fn main_result() -> anyhow::Result<i32> {
                             }
                         };
                         let sha = commit.sha.to_string();
-                        let sysroot = Sysroot::install(sha.clone(), &target_triple, &backends)
+                        let sysroot = rt
+                            .block_on(Sysroot::install(sha.clone(), &target_triple, &backends))
                             .with_context(|| {
                                 format!("failed to install sysroot for {:?}", commit)
                             })?;
@@ -1245,7 +1246,13 @@ fn main_result() -> anyhow::Result<i32> {
             let last_sha = String::from_utf8(last_sha.stdout).expect("utf8");
             let last_sha = last_sha.split_whitespace().next().expect(&last_sha);
             let commit = get_commit_or_fake_it(last_sha).expect("success");
-            let mut sysroot = Sysroot::install(commit.sha, &target_triple, &codegen_backends.0)?;
+
+            let rt = build_async_runtime();
+            let mut sysroot = rt.block_on(Sysroot::install(
+                commit.sha,
+                &target_triple,
+                &codegen_backends.0,
+            ))?;
             sysroot.preserve(); // don't delete it
 
             // Print the directory containing the toolchain.

collector/src/toolchain.rs

@@ -20,7 +20,11 @@ pub struct Sysroot {
 }
 
 impl Sysroot {
-    pub fn install(sha: String, triple: &str, backends: &[CodegenBackend]) -> anyhow::Result<Self> {
+    pub async fn install(
+        sha: String,
+        triple: &str,
+        backends: &[CodegenBackend],
+    ) -> anyhow::Result<Self> {
         let unpack_into = "cache";
 
         fs::create_dir_all(unpack_into)?;
@@ -31,12 +35,12 @@ impl Sysroot {
             triple: triple.to_owned(),
         };
 
-        download.get_and_extract(Component::Rustc)?;
-        download.get_and_extract(Component::Std)?;
-        download.get_and_extract(Component::Cargo)?;
-        download.get_and_extract(Component::RustSrc)?;
+        download.get_and_extract(Component::Rustc).await?;
+        download.get_and_extract(Component::Std).await?;
+        download.get_and_extract(Component::Cargo).await?;
+        download.get_and_extract(Component::RustSrc).await?;
         if backends.contains(&CodegenBackend::Cranelift) {
-            download.get_and_extract(Component::Cranelift)?;
+            download.get_and_extract(Component::Cranelift).await?;
         }
 
         let sysroot = download.into_sysroot()?;
@@ -141,7 +145,7 @@ impl SysrootDownload {
         })
     }
 
-    fn get_and_extract(&self, component: Component) -> anyhow::Result<()> {
+    async fn get_and_extract(&self, component: Component) -> anyhow::Result<()> {
         let archive_path = self.directory.join(format!(
             "{}-{}-{}.tar.xz",
             self.rust_sha, self.triple, component,
@@ -168,10 +172,11 @@ impl SysrootDownload {
         ];
         for url in &urls {
             log::debug!("requesting: {}", url);
-            let resp = reqwest::blocking::get(url)?;
+            let resp = reqwest::get(url).await?;
             log::debug!("{}", resp.status());
             if resp.status().is_success() {
-                let reader = XzDecoder::new(BufReader::new(resp));
+                let bytes: Vec<u8> = resp.bytes().await?.into();
+                let reader = XzDecoder::new(BufReader::new(bytes.as_slice()));
                 match self.extract(component, reader) {
                     Ok(()) => return Ok(()),
                     Err(err) => {