restructure project

1 files changed, 0 insertions, 330 deletions

diff --git a/src/launcher/jre.rs b/src/launcher/jre.rs
deleted file mode 100644
index 31034b5..0000000
--- a/src/launcher/jre.rs
+++ /dev/null
@@ -1,330 +0,0 @@
-use std::error::Error;
-use std::fmt::{Debug, Display, Formatter};
-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};
-
-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, IntegrityError};
-use crate::version::DownloadInfo;
-use super::constants;
-
-pub struct JavaRuntimeRepository {
-    online: bool,
-    home: PathBuf,
-    manifest: JavaRuntimesManifest
-}
-
-impl JavaRuntimeRepository {
-    pub async fn new(home: impl AsRef<Path>, online: bool) -> Result<Self, JavaRuntimeError> {
-        info!("Java runtime architecture is \"{}\".", JRE_ARCH);
-
-        fs::create_dir_all(&home).await.map_err(|e| JavaRuntimeError::IO { what: "creating home directory", error: e })?;
-
-        let manifest_path = home.as_ref().join("manifest.json");
-        match util::ensure_file(manifest_path.as_path(), Some(constants::URL_JRE_MANIFEST), None, None, online, true).await {
-            Ok(_) => (),
-            Err(EnsureFileError::Offline) => {
-                info!("Launcher is offline, cannot download runtime manifest.");
-            },
-            Err(e) => return Err(JavaRuntimeError::EnsureFile(e))
-        };
-
-        let manifest_file = fs::read_to_string(&manifest_path).await
-            .map_err(|e| JavaRuntimeError::IO { what: "reading runtimes manifest", error: e })?;
-
-        Ok(JavaRuntimeRepository {
-            online,
-            home: home.as_ref().to_path_buf(),
-            manifest: serde_json::from_str(&manifest_file).map_err(|e| JavaRuntimeError::Deserialize { what: "runtimes manifest", error: e })?,
-        })
-    }
-
-    fn get_component_dir(&self, component: &str) -> PathBuf {
-        [self.home.as_path(), Path::new(JRE_ARCH), Path::new(component)].into_iter().collect()
-    }
-
-    async fn load_runtime_manifest(&self, component: &str, info: &DownloadInfo) -> Result<JavaRuntimeManifest, JavaRuntimeError> {
-        let comp_dir = self.get_component_dir(component);
-        let manifest_path = comp_dir.join("manifest.json");
-
-        debug!("Ensuring manifest for runtime {JRE_ARCH}.{component}");
-
-        fs::create_dir_all(comp_dir.as_path()).await
-            .inspect_err(|e| warn!("Failed to create directory for JRE component {}: {}", component, e))
-            .map_err(|e| JavaRuntimeError::IO { what: "creating component directory", error: e })?;
-
-        util::ensure_file(&manifest_path, info.url.as_deref(), info.size, info.sha1, self.online, false).await
-            .map_err(JavaRuntimeError::EnsureFile)?;
-
-        let manifest_file = fs::read_to_string(&manifest_path).await
-            .map_err(|e| JavaRuntimeError::IO { what: "reading runtimes manifest", error: e })?;
-
-        serde_json::from_str(&manifest_file).map_err(|e| JavaRuntimeError::Deserialize { what: "runtime manifest", error: e })
-    }
-
-    // not very descriptive function name
-    pub async fn choose_runtime(&self, component: &str) -> Result<JavaRuntimeManifest, JavaRuntimeError> {
-        let Some(runtime_components) = self.manifest.get(JRE_ARCH) else {
-            return Err(JavaRuntimeError::UnsupportedArch(JRE_ARCH));
-        };
-
-        let Some(runtime_component) = runtime_components.get(component) else {
-            return Err(JavaRuntimeError::UnsupportedComponent { arch: JRE_ARCH, component: component.to_owned() });
-        };
-
-        let Some(runtime) = runtime_component.iter().find(|r| r.availability.progress == 100) else {
-            if !runtime_components.is_empty() {
-                warn!("Weird: the only java runtimes in {JRE_ARCH}.{component} has a progress of less than 100!");
-            }
-
-            return Err(JavaRuntimeError::UnsupportedComponent { arch: JRE_ARCH, component: component.to_owned() });
-        };
-
-        self.load_runtime_manifest(component, &runtime.manifest).await
-    }
-
-    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().any(|c| !matches!(&c, Component::CurDir)) {
-                // if this path is trivial (points at the root), ignore it
-                continue;
-            }
-
-            let rel_path_str = if std::path::MAIN_SEPARATOR != '/' {
-                rel_path.to_str().map(|s| s.replace(std::path::MAIN_SEPARATOR, "/"))
-            } else {
-                rel_path.to_str().map(String::from)
-            };
-
-            if !rel_path_str.as_ref().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());
-
-                if entry.file_type().is_dir() {
-                    std::fs::remove_dir(entry.path())?;
-                } else {
-                    std::fs::remove_file(entry.path())?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn clean_up_runtime(path: &Path, manifest: Arc<JavaRuntimeManifest>) -> Result<(), io::Error> {
-        let (tx, rx) = tokio::sync::oneshot::channel();
-
-        let path = path.to_owned();
-        let manifest = manifest.clone();
-
-        tokio::task::spawn_blocking(move || {
-            let res = Self::clean_up_runtime_sync(&path, manifest);
-            let _ = tx.send(res);
-        }).await.expect("clean_up_runtime_sync panicked");
-
-        rx.await.expect("clean_up_runtime_sync hung up")
-    }
-
-    async fn ensure_jre_dirs(&self, path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
-        stream::iter(manifest.files.iter().filter(|(_, f)| f.is_directory()))
-            .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>();
-
-                match fs::metadata(&ent_path).await {
-                    Ok(meta) => {
-                        if !meta.is_dir() {
-                            debug!("Deleting misplaced file at {}", ent_path.display());
-                            fs::remove_file(&ent_path).await.map_err(|e| JavaRuntimeError::IO {
-                                what: "deleting misplaced file",
-                                error: e
-                            })?;
-                        }
-                    },
-                    Err(e) if e.kind() == ErrorKind::NotFound => (),
-                    Err(e) => return Err(JavaRuntimeError::IO { what: "'stat'ing directory", error: e })
-                }
-
-                match fs::create_dir(&ent_path).await {
-                    Ok(_) => {
-                        debug!("Created directory at {}", ent_path.display());
-                        Ok(())
-                    },
-                    Err(e) if e.kind() == ErrorKind::AlreadyExists => Ok(()),
-                    Err(e) => {
-                        warn!("Could not create directory {} for JRE!", ent_path.display());
-                        Err(JavaRuntimeError::IO { what: "creating directory", error: e })
-                    }
-                }
-            }).await
-    }
-
-    async fn ensure_jre_files(path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
-        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
-                })?;
-
-                Ok(())
-            }))
-            .try_buffer_unordered(32)
-            .try_fold((), |_, _| async { Ok(()) }).await
-    }
-
-    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);
-
-        fs::create_dir_all(&runtime_path).await
-            .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.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?;
-
-        Ok(runtime_path)
-    }
-}
-
-#[derive(Debug)]
-pub enum JavaRuntimeError {
-    EnsureFile(EnsureFileError),
-    IO { what: &'static str, error: io::Error },
-    Download { what: &'static str, error: reqwest::Error },
-    Deserialize { what: &'static str, error: serde_json::Error },
-    UnsupportedArch(&'static str),
-    UnsupportedComponent { arch: &'static str, component: String },
-    MalformedManifest(&'static str),
-    Integrity(IntegrityError),
-    MultiDownloadError
-}
-
-impl Display for JavaRuntimeError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            JavaRuntimeError::EnsureFile(e) => std::fmt::Display::fmt(e, f),
-            JavaRuntimeError::IO { what, error } => write!(f, "i/o error ({}): {}", what, error),
-            JavaRuntimeError::Download { what, error } => write!(f, "error downloading {}: {}", what, error),
-            JavaRuntimeError::Deserialize { what, error } => write!(f, "error deserializing ({what}): {error}"),
-            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::MultiDownloadError => f.write_str("error in multi downloader (see logs for more details)")
-        }
-    }
-}
-
-impl Error for JavaRuntimeError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            JavaRuntimeError::EnsureFile(error) => Some(error),
-            JavaRuntimeError::IO { error, .. } => Some(error),
-            JavaRuntimeError::Download { error, .. } => Some(error),
-            JavaRuntimeError::Deserialize { error, .. } => Some(error),
-            JavaRuntimeError::Integrity(error) => Some(error),
-            _ => None
-        }
-    }
-}