finish downloaded jres

1 files changed, 106 insertions, 20 deletions

diff --git a/src/launcher/jre.rs b/src/launcher/jre.rs
index 4be4c7b..a09c8f3 100644
--- a/src/launcher/jre.rs
+++ b/src/launcher/jre.rs
@@ -1,20 +1,24 @@
 use std::collections::HashSet;
 use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
-use std::path::{Path, PathBuf};
+use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 use futures::{stream, StreamExt, TryStreamExt};
 use log::{debug, info, warn};
+use reqwest::Client;
 use tokio::{fs, io, io::ErrorKind};
 use tokio::fs::File;
 use tokio::io::AsyncWriteExt;
 
 mod arch;
 mod manifest;
+mod download;
 
 use arch::JRE_ARCH;
 use manifest::JavaRuntimesManifest;
 use manifest::JavaRuntimeManifest;
+use crate::launcher::download::MultiDownloader;
+use crate::launcher::jre::download::{LzmaDownloadError, LzmaDownloadJob};
 use crate::launcher::jre::manifest::JavaRuntimeFile;
 use crate::util;
 use crate::util::{EnsureFileError, FileVerifyError, IntegrityError};
@@ -99,13 +103,17 @@ impl JavaRuntimeRepository {
     fn clean_up_runtime_sync(path: &Path, manifest: Arc<JavaRuntimeManifest>) -> Result<(), io::Error> {
         for entry in walkdir::WalkDir::new(path).contents_first(true) {
             let entry = entry?;
+            let rel_path = entry.path().strip_prefix(path).expect("walkdir escaped root (???)");
+            
+            if rel_path.components().filter(|c| !matches!(c, Component::CurDir)).next().is_none() {
+                // if this path is trivial (points at the root), ignore it
+                continue;
+            }
 
-            if !entry.path().strip_prefix(path)
-                .expect("walkdir escaped root (???)")
-                .to_str().map_or(None, |s| manifest.files.get(s))
-                .is_none_or(|f| (f.is_file() != entry.file_type().is_file())
-                    || (f.is_directory() != entry.file_type().is_dir())
-                    || (f.is_link() != entry.file_type().is_symlink())) {
+            if !rel_path.to_str().is_some_and(|s| manifest.files.get(s)
+                .is_some_and(|f| (f.is_file() == entry.file_type().is_file())
+                    || (f.is_directory() == entry.file_type().is_dir())
+                    || (f.is_link() == entry.file_type().is_symlink()))) {
                 // path is invalid utf-8, extraneous, or of the wrong type
                 debug!("File {} is extraneous or of wrong type ({:?}). Deleting it.", entry.path().display(), entry.file_type());
 
@@ -136,7 +144,8 @@ impl JavaRuntimeRepository {
 
     async fn ensure_jre_dirs(&self, path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
         stream::iter(manifest.files.iter().filter(|(_, f)| f.is_directory()))
-            .map::<Result<_, JavaRuntimeError>, _>(|(name, _)| Ok(async move {
+            .map::<Result<&String, JavaRuntimeError>, _>(|(name, _)| Ok(name))
+            .try_for_each(|name| async move {
                 let ent_path = util::check_path(name).map_err(JavaRuntimeError::MalformedManifest)?;
                 let ent_path = [path, ent_path].into_iter().collect::<PathBuf>();
 
@@ -165,21 +174,92 @@ impl JavaRuntimeRepository {
                         return Err(JavaRuntimeError::IO { what: "creating directory", error: e });
                     }
                 }
-            }))
-            .try_buffer_unordered(32)
-            .try_fold((), |_, _| async { Ok(()) }).await
+            }).await
     }
 
     async fn ensure_jre_files(path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
-        stream::iter(manifest.files.iter().filter(|(_, f)| f.is_file()))
-            .map(|(name, file)| Ok(async move {
+        let mut downloads = Vec::new();
+        for (name, file) in manifest.files.iter().filter(|(_, f)| f.is_file()) {
+            let file_path = util::check_path(name).map_err(JavaRuntimeError::MalformedManifest)?;
+            let file_path = [path, file_path].into_iter().collect::<PathBuf>();
+
+            downloads.push(LzmaDownloadJob::try_from((file, file_path)).map_err(|e| {
+                match e {
+                    LzmaDownloadError::MissingURL => JavaRuntimeError::MalformedManifest("runtime manifest missing URL"),
+                    LzmaDownloadError::NotAFile => unreachable!("we just made sure this was a file")
+                }
+            })?);
+        }
+
+        let dl = MultiDownloader::new(downloads.iter_mut());
+        let client = Client::new();
+
+        dl.perform(&client).await
+            .inspect_err(|e| warn!("jre file download failed: {e}"))
+            .try_fold((), |_, _| async { Ok(()) })
+            .await
+            .map_err(|_| JavaRuntimeError::MultiDownloadError)
+    }
+
+    async fn ensure_links(root_path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
+        stream::iter(manifest.files.iter().filter(|(_, f)| f.is_link()))
+            .map::<Result<_, JavaRuntimeError>, _>(|(name, file)| Ok(async move {
+                let JavaRuntimeFile::Link { target } = file else {
+                    unreachable!();
+                };
+
+                let target_exp = PathBuf::from(target);
+
+                let path = util::check_path(name.as_str()).map_err(JavaRuntimeError::MalformedManifest)?;
+                let link_path = [root_path, path].into_iter().collect::<PathBuf>();
+
+                match fs::read_link(&link_path).await {
+                    Ok(target_path) => {
+                        if target_path == target_exp {
+                            debug!("Symbolic link at {} matches! Nothing to be done.", link_path.display());
+                            return Ok(())
+                        }
 
-            }));
+                        debug!("Symbolic link at {} does not match (exp {}, got {}). Recreating it.", link_path.display(), target_exp.display(), target_path.display());
+                        fs::remove_file(&link_path).await.map_err(|e| JavaRuntimeError::IO {
+                            what: "deleting bad symlink",
+                            error: e
+                        })?;
+                    }
+                    Err(e) if e.kind() == ErrorKind::NotFound => (),
+                    Err(e) => return Err(JavaRuntimeError::IO { what: "reading jre symlink", error: e })
+                }
+
+                debug!("Creating symbolic link at {} to {}", link_path.display(), target_exp.display());
+
+                let symlink;
+                #[cfg(unix)]
+                {
+                    symlink = |targ, path| async { fs::symlink(targ, path).await };
+                }
+
+                #[cfg(windows)]
+                {
+                    symlink = |targ, path| async { fs::symlink_file(targ, path).await };
+                }
+
+                #[cfg(not(any(unix, windows)))]
+                {
+                    symlink = |_, _| async { Ok(()) };
+                }
+
+                symlink(target_exp, link_path).await.map_err(|e| JavaRuntimeError::IO {
+                    what: "creating symlink",
+                    error: e
+                })?;
 
-        todo!()
+                Ok(())
+            }))
+            .try_buffer_unordered(32)
+            .try_fold((), |_, _| async { Ok(()) }).await
     }
 
-    async fn ensure_jre(&self, component: &str, manifest: JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
+    pub async fn ensure_jre(&self, component: &str, manifest: JavaRuntimeManifest) -> Result<PathBuf, JavaRuntimeError> {
         let runtime_path = self.get_component_dir(component);
         let runtime_path = runtime_path.join("runtime");
         let manifest = Arc::new(manifest);
@@ -188,15 +268,19 @@ impl JavaRuntimeRepository {
             .map_err(|e| JavaRuntimeError::IO { what: "creating runtime directory", error: e })?;
 
         debug!("Cleaning up JRE directory for {component}");
-        Self::clean_up_runtime(runtime_path.as_path(), manifest).await
+        Self::clean_up_runtime(runtime_path.as_path(), manifest.clone()).await
             .map_err(|e| JavaRuntimeError::IO { what: "cleaning up runtime directory", error: e })?;
 
         debug!("Building directory structure for {component}");
         self.ensure_jre_dirs(&runtime_path, manifest.as_ref()).await?;
 
+        debug!("Downloading JRE files for {component}");
+        Self::ensure_jre_files(&runtime_path, manifest.as_ref()).await?;
 
+        debug!("Ensuring symbolic links for {component}");
+        Self::ensure_links(&runtime_path, manifest.as_ref()).await?;
 
-        todo!()
+        Ok(runtime_path)
     }
 }
 
@@ -209,7 +293,8 @@ pub enum JavaRuntimeError {
     UnsupportedArch(&'static str),
     UnsupportedComponent { arch: &'static str, component: String },
     MalformedManifest(&'static str),
-    Integrity(IntegrityError)
+    Integrity(IntegrityError),
+    MultiDownloadError
 }
 
 impl Display for JavaRuntimeError {
@@ -222,7 +307,8 @@ impl Display for JavaRuntimeError {
             JavaRuntimeError::UnsupportedArch(arch) => write!(f, r#"unsupported architecture "{arch}""#),
             JavaRuntimeError::UnsupportedComponent { arch, component } => write!(f, r#"unsupported component "{component}" for architecture "{arch}""#),
             JavaRuntimeError::MalformedManifest(what) => write!(f, "malformed runtime manifest: {what} (launcher bug?)"),
-            JavaRuntimeError::Integrity(e) => std::fmt::Display::fmt(e, f)
+            JavaRuntimeError::Integrity(e) => std::fmt::Display::fmt(e, f),
+            JavaRuntimeError::MultiDownloadError => f.write_str("error in multi downloader (see logs for more details)")
         }
     }
 }