elemental-driver 0.2.0

Driver library for Elemental, providing implementations for interacting with different modloaders and game versions.
Documentation
use std::{
    collections::HashSet,
    path::{Path, PathBuf},
};

use elemental_core::runtime::distribution::Distribution;
use elemental_infra::jar::JarFile;
use elemental_schema::forge::ForgeInstallerProcessor;
use tokio::{fs::create_dir_all, process::Command};

use crate::{
    error::{Error, ProcessorFailure, Result},
    families::version_json::classpath::join_classpath,
};

use super::context::InstallerProcessorContext;

pub(super) async fn run_processor(
    runtime: &Distribution,
    context: &InstallerProcessorContext<'_>,
    processor: &ForgeInstallerProcessor,
) -> Result<()> {
    let processor_jar_path = context.processor_jar_path(processor)?;
    let main_class =
        tokio::task::spawn_blocking(move || read_jar_main_class(&processor_jar_path)).await??;
    let classpath = join_processor_classpath(context, processor)?;
    let mut resolved_args = Vec::with_capacity(processor.args.len());
    for argument in &processor.args {
        resolved_args.push(context.resolve_argument(argument.as_str()).await?);
    }

    ensure_output_directories(context, processor).await?;

    let output = Command::new(runtime.executable())
        .arg("-cp")
        .arg(&classpath)
        .arg(main_class.as_str())
        .args(resolved_args.as_slice())
        .current_dir(&context.root_directory)
        .output()
        .await
        .map_err(|source| Error::RunProcessor {
            family_name: context.family_name.to_owned(),
            processor: processor.jar.clone(),
            source,
        })?;

    if output.status.success() {
        return Ok(());
    }

    Err(Error::ProcessorFailed(Box::new(ProcessorFailure {
        family_name: context.family_name.to_owned(),
        processor: processor.jar.clone(),
        java: runtime.executable().display().to_string(),
        main_class,
        classpath,
        args: resolved_args,
        exit_status: output.status.code(),
        stdout: String::from_utf8_lossy(&output.stdout).to_string(),
        stderr: String::from_utf8_lossy(&output.stderr).to_string(),
    })))
}

fn join_processor_classpath(
    context: &InstallerProcessorContext<'_>,
    processor: &ForgeInstallerProcessor,
) -> Result<String> {
    let entries = context.processor_classpath(processor)?;
    Ok(join_classpath(
        entries
            .iter()
            .map(|path| path.to_string_lossy().to_string())
            .collect(),
    ))
}

fn read_jar_main_class(path: &Path) -> Result<String> {
    let manifest = JarFile::new(path).by_name_string("META-INF/MANIFEST.MF")?;
    unfold_manifest_lines(manifest.as_str())
        .lines()
        .find_map(|line| line.strip_prefix("Main-Class: "))
        .map(str::trim)
        .map(ToOwned::to_owned)
        .ok_or_else(|| Error::JarMainClassMissing {
            path: path.to_path_buf(),
        })
}

fn unfold_manifest_lines(manifest: &str) -> String {
    manifest
        .lines()
        .fold(Vec::<String>::new(), |mut lines, line| {
            if let Some(last) = lines.last_mut()
                && let Some(continued) = line.strip_prefix(' ')
            {
                last.push_str(continued);
            } else {
                lines.push(line.to_owned());
            }
            lines
        })
        .join("\n")
}

async fn ensure_output_directories(
    context: &InstallerProcessorContext<'_>,
    processor: &ForgeInstallerProcessor,
) -> Result<()> {
    let mut parents = HashSet::new();
    for output in processor.outputs.keys() {
        let path = PathBuf::from(context.resolve_argument(output).await?);
        if let Some(parent) = path
            .parent()
            .filter(|parent| !parent.as_os_str().is_empty())
        {
            parents.insert(parent.to_path_buf());
        }
    }

    for parent in parents {
        create_dir_all(parent).await?;
    }

    Ok(())
}