RustJava 0.4.0

An embeddable JVM and Java runtime implemented in Rust
Documentation
extern crate alloc;

mod runtime;

use std::{env, io::Write, path::Path};

use jvm::{JavaError, JavaValue, Jvm, Result, runtime::JavaLangString};
use rustjava_runtime::{Runtime, get_bootstrap_class_loader};

use runtime::RuntimeImpl;

pub enum StartType<'a> {
    Jar(&'a Path),
    Class(&'a Path),
}

pub async fn run<T, S>(stdout: T, start_type: StartType<'_>, args: &[S], class_path: &[&Path]) -> anyhow::Result<()>
where
    T: Sync + Send + Write + 'static,
    S: AsRef<str>,
{
    let jvm = create_jvm(stdout, &start_type, class_path).await?;

    let result = invoke_entrypoint(&jvm, &start_type, args).await;

    if let Err(JavaError::JavaException(x)) = result {
        let string_writer = jvm.new_class("java/io/StringWriter", "()V", ()).await.unwrap();
        let print_writer = jvm
            .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (string_writer.clone(),))
            .await
            .unwrap();

        let _: () = jvm
            .invoke_virtual(&x, "java/lang/Throwable", "printStackTrace", "(Ljava/io/PrintWriter;)V", (print_writer,))
            .await
            .unwrap();

        let trace = jvm
            .invoke_virtual(&string_writer, "java/io/StringWriter", "toString", "()Ljava/lang/String;", [])
            .await
            .unwrap();

        Err(anyhow::anyhow!(
            "Java Exception:\n{}",
            JavaLangString::to_rust_string(&jvm, &trace).await.unwrap()
        ))
    } else {
        Ok(result?)
    }
}

async fn create_jvm<T>(stdout: T, start_type: &StartType<'_>, class_path: &[&Path]) -> anyhow::Result<Jvm>
where
    T: Sync + Send + Write + 'static,
{
    let runtime = Box::new(RuntimeImpl::new(stdout)) as Box<dyn Runtime>;

    let bootstrap_class_loader = get_bootstrap_class_loader(runtime.clone());

    let class_path_str = build_class_path(start_type, class_path)?;
    let properties = [("java.class.path", class_path_str.as_str())].into_iter().collect();

    Ok(Jvm::new(bootstrap_class_loader, move || runtime.current_task_id(), properties, None).await?)
}

fn build_class_path(start_type: &StartType<'_>, class_path: &[&Path]) -> anyhow::Result<String> {
    let mut entries = Vec::new();
    if let StartType::Jar(path) = start_type {
        entries.push(path.as_os_str());
    }
    entries.extend(class_path.iter().map(|path| path.as_os_str()));

    env::join_paths(entries)?
        .into_string()
        .map_err(|_| anyhow::anyhow!("Class path contains a non-UTF-8 path"))
}

async fn invoke_entrypoint<S>(jvm: &Jvm, start_type: &StartType<'_>, args: &[S]) -> Result<()>
where
    S: AsRef<str>,
{
    let main_class_name = match start_type {
        StartType::Jar(x) => &get_jar_main_class(jvm, x).await?,
        StartType::Class(x) => x.file_stem().unwrap().to_str().unwrap(),
    };

    let mut java_args = Vec::with_capacity(args.len());
    for arg in args {
        java_args.push(JavaLangString::from_rust_string(jvm, arg.as_ref()).await?);
    }
    let mut array = jvm.instantiate_array("Ljava/lang/String;", args.len()).await?;
    jvm.store_array(&mut array, 0, java_args).await.unwrap();

    let normalized_name = main_class_name.replace('.', "/");
    let _: () = jvm
        .invoke_static(&normalized_name, "main", "([Ljava/lang/String;)V", [JavaValue::Object(Some(array))])
        .await?;

    Ok(())
}

async fn get_jar_main_class(jvm: &Jvm, jar_path: &Path) -> Result<String> {
    let filename = JavaLangString::from_rust_string(jvm, jar_path.to_str().unwrap()).await?;
    let file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (filename,)).await?;
    let jar_file = jvm.new_class("java/util/jar/JarFile", "(Ljava/io/File;)V", (file,)).await?;

    let manifest = jvm
        .invoke_virtual(&jar_file, "java/util/jar/JarFile", "getManifest", "()Ljava/util/jar/Manifest;", ())
        .await?;
    let attributes = jvm
        .invoke_virtual(
            &manifest,
            "java/util/jar/Manifest",
            "getMainAttributes",
            "()Ljava/util/jar/Attributes;",
            (),
        )
        .await?;

    let main_class = jvm
        .invoke_virtual(
            &attributes,
            "java/util/jar/Attributes",
            "getValue",
            "(Ljava/lang/String;)Ljava/lang/String;",
            (JavaLangString::from_rust_string(jvm, "Main-Class").await?,),
        )
        .await?;

    JavaLangString::to_rust_string(jvm, &main_class).await
}

#[cfg(test)]
mod tests {
    use std::{env, path::Path};

    use super::{StartType, build_class_path};

    #[test]
    fn class_launch_classpath_preserves_order_and_empty_entries() {
        assert_eq!(
            build_class_path(
                &StartType::Class(Path::new("Main")),
                &[Path::new("classes"), Path::new(""), Path::new("lib/dependency.jar")],
            )
            .unwrap(),
            env::join_paths(["classes", "", "lib/dependency.jar"]).unwrap().into_string().unwrap()
        );
    }

    #[test]
    fn jar_launch_classpath_has_no_trailing_separator_without_user_entries() {
        assert_eq!(build_class_path(&StartType::Jar(Path::new("app.jar")), &[]).unwrap(), "app.jar");
    }

    #[test]
    fn jar_library_api_preserves_explicit_user_classpath() {
        assert_eq!(
            build_class_path(&StartType::Jar(Path::new("app.jar")), &[Path::new("lib/dependency.jar")]).unwrap(),
            env::join_paths(["app.jar", "lib/dependency.jar"]).unwrap().into_string().unwrap()
        );
    }

    #[test]
    fn empty_class_launch_has_no_bootstrap_entry_in_application_classpath() {
        assert_eq!(build_class_path(&StartType::Class(Path::new("Main")), &[]).unwrap(), "");
    }

    #[cfg(unix)]
    #[test]
    fn classpath_rejects_non_utf8_entries() {
        use std::{ffi::OsString, os::unix::ffi::OsStringExt, path::PathBuf};

        let path = PathBuf::from(OsString::from_vec(vec![0xff]));
        let error = build_class_path(&StartType::Class(Path::new("Main")), &[&path]).unwrap_err();

        assert_eq!(error.to_string(), "Class path contains a non-UTF-8 path");
    }
}