crust_core 1.0.3

Core library to download, install and launch Minecraft (versions, assets, libraries, Java runtime, mod loaders)
Documentation
use std::path::Path;

use crate::foundation::events::{Event, EventHandler};
use crate::foundation::maven::library_path;
use crate::foundation::options::LoaderKind;
use crate::network::{DownloadItem, Downloader, HttpClient};
use crate::providers::fabric::{Endpoints, FabricMeta};

use super::{Error, InstallConfig, LoaderJson, emit, mirrors, write_version_files};

pub async fn install(
    http: &HttpClient,
    config: &InstallConfig,
    events: &EventHandler,
) -> Result<LoaderJson, Error> {
    let endpoints = Endpoints::for_kind(config.kind)
        .ok_or_else(|| Error::Unsupported(format!("Loader {} not found", config.kind)))?;
    let meta = FabricMeta::new(http.clone(), endpoints);
    let raw = download_json(&meta, config).await?;
    let json = LoaderJson::from_value(raw, config.loader_dir.clone())?;

    if let Some(id) = &json.id {
        write_version_files(&config.loader_dir, id, &json.raw, &config.minecraft_jar)?;
    }
    download_libraries(http, config, &json, events).await?;
    Ok(json)
}

async fn download_json(
    meta: &FabricMeta,
    config: &InstallConfig,
) -> Result<serde_json::Value, Error> {
    let versions = meta.versions().await?;
    let label = match config.kind {
        LoaderKind::Quilt => "QuiltMC",
        _ => "FabricMC",
    };
    if !versions
        .game
        .iter()
        .any(|game| game.version == config.minecraft_version)
    {
        return Err(Error::Unsupported(format!(
            "{label} doesn't support Minecraft {}",
            config.minecraft_version
        )));
    }
    let available: Vec<&str> = versions
        .loader
        .iter()
        .map(|loader| loader.version.as_str())
        .collect();
    let selected = match (config.kind, config.build.as_str()) {
        (LoaderKind::Quilt, "latest") => versions.loader.first(),
        (LoaderKind::Quilt, "recommended") => versions
            .loader
            .iter()
            .find(|loader| !loader.version.contains("beta")),
        (_, "latest" | "recommended") => versions.loader.first(),
        (_, build) => versions
            .loader
            .iter()
            .find(|loader| loader.version == build),
    };
    let Some(selected) = selected else {
        let name = match config.kind {
            LoaderKind::Quilt => "QuiltMC Loader",
            _ => "Fabric Loader",
        };
        return Err(Error::Unsupported(format!(
            "{name} {} not found, Available builds: {}",
            config.build,
            available.join(", ")
        )));
    };
    Ok(meta
        .profile(&config.minecraft_version, &selected.version)
        .await?)
}

async fn download_libraries(
    http: &HttpClient,
    config: &InstallConfig,
    json: &LoaderJson,
    events: &EventHandler,
) -> Result<(), Error> {
    let total = json.libraries.len();
    let mut checked = 0usize;
    let mut queue = Vec::new();
    let mut total_size = 0u64;

    for library in &json.libraries {
        if library.rules.is_some() {
            emit(events, check(checked, total));
            checked += 1;
            continue;
        }
        let info = library_path(&library.name, None, None);
        let file_path = config
            .loader_dir
            .join("libraries")
            .join(&info.path)
            .join(&info.name);
        if !file_path.exists() {
            let url = format!(
                "{}{}/{}",
                library.url.as_deref().unwrap_or_default(),
                info.path,
                info.name
            );
            let mut size = 0;
            if let Some(found) = mirrors::check_url(http, &url, config.timeout).await {
                size = found;
                total_size += found;
            }
            queue.push(DownloadItem {
                url,
                path: file_path,
                sha1: None,
                size: Some(size),
                executable: false,
                label: "libraries".to_owned(),
            });
        }
        emit(events, check(checked, total));
        checked += 1;
    }

    if !queue.is_empty() {
        let events_for_progress = events.clone();
        let failures = Downloader::new(http.clone(), config.concurrency)
            .download_all_lenient(
                queue,
                std::sync::Arc::new(move |progress| {
                    events_for_progress(Event::Progress {
                        downloaded: progress.downloaded,
                        total: total_size.max(progress.total),
                        element: "libraries".to_owned(),
                    });
                }),
            )
            .await?;
        for failure in failures {
            emit(events, Event::Error(failure.to_string()));
        }
    }
    Ok(())
}

fn check(checked: usize, total: usize) -> Event {
    Event::Check {
        checked,
        total,
        element: "libraries".to_owned(),
    }
}

#[allow(dead_code)]
fn library_file(loader_dir: &Path, name: &str) -> std::path::PathBuf {
    let info = library_path(name, None, None);
    loader_dir.join("libraries").join(info.path).join(info.name)
}