crust_core 1.0.3

Core library to download, install and launch Minecraft (versions, assets, libraries, Java runtime, mod loaders)
Documentation
mod archive;
mod fabric;
mod forgelike;
mod mirrors;
mod patcher;

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::time::Duration;

use serde::{Deserialize, Serialize};

use crate::foundation::events::{Event, EventHandler};
use crate::foundation::options::LoaderKind;
use crate::network::{self, HttpClient};
use crate::providers::launchermeta::{Argument, Library};
use crate::providers::{fabric as fabric_meta, forge as forge_meta, neoforge as neoforge_meta};

pub use forgelike::Flavor;

#[derive(Debug, Clone)]
pub struct InstallConfig {
    pub kind: LoaderKind,
    pub minecraft_version: String,
    pub build: String,
    pub loader_dir: PathBuf,
    pub java_path: PathBuf,
    pub minecraft_jar: PathBuf,
    pub minecraft_json: PathBuf,
    pub concurrency: usize,
    pub timeout: Duration,
}

#[derive(Debug, Clone)]
pub struct LoaderJson {
    pub raw: serde_json::Value,
    pub id: Option<String>,
    pub main_class: Option<String>,
    pub inherits_from: Option<String>,
    pub minecraft_arguments: Option<String>,
    pub game_arguments: Vec<String>,
    pub jvm_arguments: Vec<String>,
    pub libraries: Vec<Library>,
    pub loader_dir: PathBuf,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct LoaderJsonView {
    #[serde(default)]
    id: Option<String>,
    #[serde(rename = "mainClass", default)]
    main_class: Option<String>,
    #[serde(rename = "inheritsFrom", default)]
    inherits_from: Option<String>,
    #[serde(rename = "minecraftArguments", default)]
    minecraft_arguments: Option<String>,
    #[serde(default)]
    arguments: Option<LoaderArguments>,
    #[serde(default)]
    libraries: Vec<Library>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct LoaderArguments {
    #[serde(default)]
    game: Vec<Argument>,
    #[serde(default)]
    jvm: Vec<Argument>,
}

impl LoaderJson {
    pub fn from_value(raw: serde_json::Value, loader_dir: PathBuf) -> Result<Self, Error> {
        let view: LoaderJsonView = serde_json::from_value(raw.clone())?;
        let arguments = view.arguments.unwrap_or_default();
        Ok(Self {
            raw,
            id: view.id,
            main_class: view.main_class,
            inherits_from: view.inherits_from,
            minecraft_arguments: view.minecraft_arguments,
            game_arguments: plain_strings(&arguments.game),
            jvm_arguments: plain_strings(&arguments.jvm),
            libraries: view.libraries,
            loader_dir,
        })
    }
}

fn plain_strings(arguments: &[Argument]) -> Vec<String> {
    arguments
        .iter()
        .filter_map(|argument| match argument {
            Argument::Plain(value) => Some(value.clone()),
            Argument::Conditional { .. } => None,
        })
        .collect()
}

#[derive(Debug, Clone, Default, Deserialize)]
pub struct InstallSection {
    #[serde(default)]
    pub libraries: Vec<Library>,
    #[serde(default)]
    pub processors: Vec<Processor>,
    #[serde(default)]
    pub data: HashMap<String, DataEntry>,
    #[serde(default)]
    pub path: Option<String>,
    #[serde(rename = "filePath", default)]
    pub file_path: Option<String>,
    #[serde(default)]
    pub json: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct Processor {
    pub jar: String,
    #[serde(default)]
    pub args: Vec<String>,
    #[serde(default)]
    pub classpath: Vec<String>,
    #[serde(default)]
    pub sides: Option<Vec<String>>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct DataEntry {
    #[serde(default)]
    pub client: String,
    #[serde(default)]
    pub server: String,
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error(transparent)]
    Network(#[from] network::Error),
    #[error(transparent)]
    Forge(#[from] forge_meta::Error),
    #[error(transparent)]
    NeoForge(#[from] neoforge_meta::Error),
    #[error(transparent)]
    Fabric(#[from] fabric_meta::Error),
    #[error("{0}")]
    Unsupported(String),
    #[error("{0}")]
    Invalid(String),
    #[error("invalid json: {0}")]
    Json(#[from] serde_json::Error),
    #[error("io error on {path}: {source}")]
    Io {
        path: String,
        #[source]
        source: std::io::Error,
    },
    #[error("failed to read archive {path}: {source}")]
    Zip {
        path: String,
        #[source]
        source: zip::result::ZipError,
    },
    #[error("background task failed: {0}")]
    Join(#[from] tokio::task::JoinError),
}

pub async fn install(
    http: &HttpClient,
    config: &InstallConfig,
    events: &EventHandler,
) -> Result<LoaderJson, Error> {
    let json = match config.kind {
        LoaderKind::Forge => forgelike::install(http, config, Flavor::Forge, events).await?,
        LoaderKind::NeoForge => forgelike::install(http, config, Flavor::NeoForge, events).await?,
        LoaderKind::Fabric | LoaderKind::LegacyFabric | LoaderKind::Quilt => {
            fabric::install(http, config, events).await?
        }
    };
    Ok(json)
}

pub(crate) fn patch_libraries(json: &mut LoaderJson, platform: crate::foundation::os::Platform) {
    json.libraries = crate::resolver::patches::apply(&json.libraries, platform);
}

pub(crate) fn write_version_files(
    loader_dir: &Path,
    id: &str,
    json: &serde_json::Value,
    minecraft_jar: &Path,
) -> Result<(), Error> {
    let destination = loader_dir.join("versions").join(id);
    std::fs::create_dir_all(&destination).map_err(|source| io_error(&destination, source))?;
    let json_path = destination.join(format!("{id}.json"));
    let content = serde_json::to_string_pretty(json)?;
    std::fs::write(&json_path, content).map_err(|source| io_error(&json_path, source))?;
    let jar_path = destination.join(format!("{id}.jar"));
    std::fs::copy(minecraft_jar, &jar_path).map_err(|source| io_error(&jar_path, source))?;
    Ok(())
}

pub(crate) fn write_bytes(path: &Path, bytes: &[u8]) -> Result<(), Error> {
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent).map_err(|source| io_error(parent, source))?;
    }
    std::fs::write(path, bytes).map_err(|source| io_error(path, source))
}

pub(crate) fn io_error(path: &Path, source: std::io::Error) -> Error {
    Error::Io {
        path: path.display().to_string(),
        source,
    }
}

pub(crate) fn emit(events: &EventHandler, event: Event) {
    events(event);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_fabric_profile_json() {
        let raw: serde_json::Value = serde_json::from_str(
            r#"{
            "id": "fabric-loader-0.16.9-1.20.1",
            "inheritsFrom": "1.20.1",
            "mainClass": "net.fabricmc.loader.impl.launch.knot.KnotClient",
            "arguments": {"game": [], "jvm": ["-DFabricMcEmu= net.minecraft.client.main.Main "]},
            "libraries": [{"name": "org.ow2.asm:asm:9.7.1", "url": "https://maven.fabricmc.net/", "sha1": "x", "size": 1}]
        }"#,
        )
        .unwrap();
        let json = LoaderJson::from_value(raw, PathBuf::from("/root/loader")).unwrap();
        assert_eq!(json.id.as_deref(), Some("fabric-loader-0.16.9-1.20.1"));
        assert_eq!(
            json.jvm_arguments,
            vec!["-DFabricMcEmu= net.minecraft.client.main.Main "]
        );
        assert!(json.game_arguments.is_empty());
        assert_eq!(
            json.libraries[0].url.as_deref(),
            Some("https://maven.fabricmc.net/")
        );
    }

    #[test]
    fn parses_old_forge_version_info() {
        let raw: serde_json::Value = serde_json::from_str(
            r#"{
            "id": "1.7.10-Forge10.13.4.1614-1.7.10",
            "mainClass": "net.minecraft.launchwrapper.Launch",
            "minecraftArguments": "--username ${auth_player_name} --tweakClass cpw.mods.fml.common.launcher.FMLTweaker",
            "jar": "1.7.10",
            "libraries": [{"name": "net.minecraftforge:forge:1.7.10-10.13.4.1614-1.7.10", "url": "https://maven.minecraftforge.net/"}, {"name": "net.minecraft:launchwrapper:1.12"}]
        }"#,
        )
        .unwrap();
        let json = LoaderJson::from_value(raw, PathBuf::from("/root")).unwrap();
        assert!(json.minecraft_arguments.is_some());
        assert_eq!(json.libraries.len(), 2);
        assert!(json.libraries[1].downloads.is_none());
    }

    #[test]
    fn loader_jna_is_upgraded_on_macos() {
        let raw: serde_json::Value = serde_json::from_str(
            r#"{
            "id": "1.18.2-forge-40.3.12",
            "mainClass": "cpw.mods.bootstraplauncher.BootstrapLauncher",
            "arguments": {"game": [], "jvm": ["-DmergeModules=jna-5.12.1.jar,jna-platform-5.12.1.jar,java-objc-bridge-1.0.0.jar"]},
            "libraries": [
                {"name": "net.java.dev.jna:jna:5.12.1", "downloads": {"artifact": {"path": "net/java/dev/jna/jna/5.12.1/jna-5.12.1.jar", "sha1": "a", "size": 1, "url": "https://maven.minecraftforge.net/net/java/dev/jna/jna/5.12.1/jna-5.12.1.jar"}}},
                {"name": "net.java.dev.jna:jna-platform:5.12.1", "downloads": {"artifact": {"path": "net/java/dev/jna/jna-platform/5.12.1/jna-platform-5.12.1.jar", "sha1": "b", "size": 1, "url": "https://maven.minecraftforge.net/net/java/dev/jna/jna-platform/5.12.1/jna-platform-5.12.1.jar"}}},
                {"name": "ca.weblite:java-objc-bridge:1.0.0"}
            ]
        }"#,
        )
        .unwrap();
        let mut json = LoaderJson::from_value(raw.clone(), PathBuf::from("/root")).unwrap();
        patch_libraries(&mut json, crate::foundation::os::Platform::MacOs);
        let names: Vec<&str> = json.libraries.iter().map(|l| l.name.as_str()).collect();
        assert_eq!(
            names,
            vec![
                "net.java.dev.jna:jna:5.13.0",
                "net.java.dev.jna:jna-platform:5.13.0",
                "ca.weblite:java-objc-bridge:1.0.0"
            ]
        );
        assert_eq!(json.raw, raw);

        let mut windows = LoaderJson::from_value(raw, PathBuf::from("/root")).unwrap();
        patch_libraries(&mut windows, crate::foundation::os::Platform::Windows);
        assert_eq!(windows.libraries[0].name, "net.java.dev.jna:jna:5.12.1");
    }
}