centralcore 1.0.2

Open-source Rust library for building Minecraft Java Edition launchers
Documentation
use std::{
    ffi::OsString,
    io::{Read, Write},
    path::{Path, PathBuf},
};

use tokio::process::Command;

use crate::{
    download::{compute_hash, verify_file, CancellationToken},
    events::{CoreEvent, EventBus},
    files::HashAlgorithm,
    instance::Instance,
    java::{JavaManager, JavaRequirement},
    Result,
};

use super::{LoaderError, LoaderPlan, ProcessorArgument, ProcessorPlan};

const PLAN_FILE: &str = "runtime/loader-plan.json";

pub(crate) async fn write_loader_plan(instance: &Instance, plan: &LoaderPlan) -> Result<()> {
    plan.validate()?;
    let runtime = instance.path().join("runtime");
    tokio::fs::create_dir_all(&runtime).await?;
    let bytes = serde_json::to_vec_pretty(plan)?;
    let temporary = runtime.join("loader-plan.json.tmp");
    tokio::fs::write(&temporary, bytes).await?;
    let target = instance.path().join(PLAN_FILE);
    if tokio::fs::try_exists(&target).await? {
        tokio::fs::remove_file(&target).await?;
    }
    tokio::fs::rename(temporary, target).await?;
    Ok(())
}

pub(crate) async fn load_loader_plan(instance: &Instance) -> Result<Option<LoaderPlan>> {
    let path = instance.path().join(PLAN_FILE);
    let bytes = match tokio::fs::read(path).await {
        Ok(bytes) => bytes,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
        Err(error) => return Err(error.into()),
    };
    let plan: LoaderPlan = serde_json::from_slice(&bytes)?;
    plan.validate()?;
    Ok(Some(plan))
}

pub(crate) async fn execute_loader_plan(
    plan: &mut LoaderPlan,
    instance: &Instance,
    cache_root: &Path,
    java: &JavaManager,
    events: &EventBus,
    cancellation: &CancellationToken,
) -> Result<()> {
    let cache_root = normalize_path(tokio::fs::canonicalize(cache_root).await?);
    for extraction in &plan.archive_entries {
        if cancellation.is_cancelled() {
            return Err(crate::download::DownloadError::Cancelled.into());
        }
        let archive = extraction.archive.join_under(&cache_root);
        let destination = extraction.destination.join_under(&cache_root);
        extract_exact_entry(archive, extraction.entry.clone(), destination.clone()).await?;
        verify_file(&destination, None, extraction.expected_hash.as_ref()).await?;
    }

    if plan.processors.is_empty() {
        return Ok(());
    }
    let java_executable = java
        .resolve_runtime(
            instance.spec().java().executable.as_deref(),
            JavaRequirement::current(plan.minimum_java_major.unwrap_or(8)),
            cancellation,
        )
        .await?
        .executable;
    for processor in &mut plan.processors {
        if cancellation.is_cancelled() {
            return Err(crate::download::DownloadError::Cancelled.into());
        }
        if outputs_are_valid(&cache_root, processor).await {
            continue;
        }
        events.emit(CoreEvent::LoaderProcessorStarted {
            instance_id: instance.id().to_string(),
            processor_id: processor.id.clone(),
        });
        execute_processor(&cache_root, &java_executable, processor).await?;
        snapshot_outputs(&cache_root, processor).await?;
        events.emit(CoreEvent::LoaderProcessorCompleted {
            instance_id: instance.id().to_string(),
            processor_id: processor.id.clone(),
        });
    }
    Ok(())
}

fn normalize_path(path: PathBuf) -> PathBuf {
    if !cfg!(windows) {
        return path;
    }
    let value = path.to_string_lossy();
    if let Some(path) = value.strip_prefix(r"\\?\UNC\") {
        PathBuf::from(format!(r"\\{path}"))
    } else if let Some(path) = value.strip_prefix(r"\\?\") {
        PathBuf::from(path)
    } else {
        path
    }
}

async fn outputs_are_valid(root: &Path, processor: &ProcessorPlan) -> bool {
    if processor.outputs.is_empty() {
        return false;
    }
    for output in &processor.outputs {
        if output.expected_size.is_none() && output.expected_hash.is_none() {
            return false;
        }
        if verify_file(
            &output.path.join_under(root),
            output.expected_size,
            output.expected_hash.as_ref(),
        )
        .await
        .is_err()
        {
            return false;
        }
    }
    true
}

async fn execute_processor(root: &Path, java: &Path, processor: &ProcessorPlan) -> Result<()> {
    let jar = processor.jar.join_under(root);
    let main_class = processor_main_class(jar.clone()).await?;
    let mut entries = Vec::with_capacity(processor.classpath.len() + 1);
    entries.push(jar);
    entries.extend(processor.classpath.iter().map(|path| path.join_under(root)));
    let classpath = std::env::join_paths(entries)
        .map_err(|error| LoaderError::InvalidPlan(error.to_string()))?;
    let arguments = processor
        .arguments
        .iter()
        .map(|argument| match argument {
            ProcessorArgument::Literal(value) => OsString::from(value),
            ProcessorArgument::CacheRoot => root.as_os_str().to_owned(),
            ProcessorArgument::CachePath(path) => path.join_under(root).into_os_string(),
        })
        .collect::<Vec<_>>();
    tracing::debug!(
        processor = %processor.id,
        java = %java.display(),
        classpath = %classpath.to_string_lossy(),
        "executing loader processor"
    );
    let status = Command::new(java)
        .arg("-cp")
        .arg(classpath)
        .arg(main_class)
        .args(arguments)
        .current_dir(root)
        .status()
        .await?;
    if !status.success() {
        return Err(LoaderError::ProcessorFailed {
            id: processor.id.clone(),
            code: status.code(),
        }
        .into());
    }
    Ok(())
}

async fn snapshot_outputs(root: &Path, processor: &mut ProcessorPlan) -> Result<()> {
    for output in &mut processor.outputs {
        let path = output.path.join_under(root);
        let metadata = tokio::fs::symlink_metadata(&path).await.map_err(|_| {
            LoaderError::InvalidProcessorOutput {
                id: processor.id.clone(),
                path: output.path.to_string(),
            }
        })?;
        if !metadata.is_file() || metadata.file_type().is_symlink() {
            return Err(LoaderError::InvalidProcessorOutput {
                id: processor.id.clone(),
                path: output.path.to_string(),
            }
            .into());
        }
        output.expected_size = Some(metadata.len());
        match &output.expected_hash {
            Some(hash) => {
                verify_file(&path, Some(metadata.len()), Some(hash)).await?;
            }
            None => {
                output.expected_hash = Some(compute_hash(&path, HashAlgorithm::Sha256).await?);
            }
        }
    }
    Ok(())
}

async fn processor_main_class(jar: PathBuf) -> Result<String> {
    tokio::task::spawn_blocking(move || {
        let file = std::fs::File::open(jar)?;
        let mut archive = zip::ZipArchive::new(file).map_err(|error| {
            LoaderError::InvalidMetadata(format!("invalid processor archive: {error}"))
        })?;
        let mut manifest = archive.by_name("META-INF/MANIFEST.MF").map_err(|error| {
            LoaderError::InvalidMetadata(format!("processor manifest is missing: {error}"))
        })?;
        let mut text = String::new();
        manifest.read_to_string(&mut text)?;
        text.lines()
            .find_map(|line| line.strip_prefix("Main-Class:").map(str::trim))
            .filter(|value| !value.is_empty())
            .map(str::to_owned)
            .ok_or_else(|| {
                LoaderError::InvalidMetadata("processor Main-Class is missing".into()).into()
            })
    })
    .await
    .map_err(|error| LoaderError::InvalidMetadata(error.to_string()))?
}

async fn extract_exact_entry(archive: PathBuf, entry: String, destination: PathBuf) -> Result<()> {
    tokio::task::spawn_blocking(move || {
        let parent = destination
            .parent()
            .ok_or_else(|| LoaderError::InvalidPlan("archive destination has no parent".into()))?;
        std::fs::create_dir_all(parent)?;
        let file = std::fs::File::open(archive)?;
        let mut zip = zip::ZipArchive::new(file)
            .map_err(|error| LoaderError::InvalidMetadata(error.to_string()))?;
        let entry = entry.trim_start_matches('/');
        let mut source = zip
            .by_name(entry)
            .map_err(|error| LoaderError::InvalidMetadata(error.to_string()))?;
        if source.is_dir() {
            return Err(LoaderError::InvalidPlan("archive entry is a directory".into()).into());
        }
        let temporary = destination.with_extension("loader.tmp");
        let mut target = std::fs::File::create(&temporary)?;
        std::io::copy(&mut source, &mut target)?;
        target.flush()?;
        drop(target);
        if destination.exists() {
            std::fs::remove_file(&destination)?;
        }
        std::fs::rename(temporary, destination)?;
        Ok(())
    })
    .await
    .map_err(|error| LoaderError::InvalidMetadata(error.to_string()))?
}