Skip to main content

rust_java/
lib.rs

1extern crate alloc;
2
3mod runtime;
4
5use std::{env, io::Write, path::Path};
6
7use jvm::{JavaError, JavaValue, Jvm, Result, runtime::JavaLangString};
8use rustjava_runtime::{Runtime, get_bootstrap_class_loader};
9
10use runtime::RuntimeImpl;
11
12pub enum StartType<'a> {
13    Jar(&'a Path),
14    Class(&'a Path),
15}
16
17pub async fn run<T, S>(stdout: T, start_type: StartType<'_>, args: &[S], class_path: &[&Path]) -> anyhow::Result<()>
18where
19    T: Sync + Send + Write + 'static,
20    S: AsRef<str>,
21{
22    let jvm = create_jvm(stdout, &start_type, class_path).await?;
23
24    let result = invoke_entrypoint(&jvm, &start_type, args).await;
25
26    if let Err(JavaError::JavaException(x)) = result {
27        let string_writer = jvm.new_class("java/io/StringWriter", "()V", ()).await.unwrap();
28        let print_writer = jvm
29            .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (string_writer.clone(),))
30            .await
31            .unwrap();
32
33        let _: () = jvm
34            .invoke_virtual(&x, "java/lang/Throwable", "printStackTrace", "(Ljava/io/PrintWriter;)V", (print_writer,))
35            .await
36            .unwrap();
37
38        let trace = jvm
39            .invoke_virtual(&string_writer, "java/io/StringWriter", "toString", "()Ljava/lang/String;", [])
40            .await
41            .unwrap();
42
43        Err(anyhow::anyhow!(
44            "Java Exception:\n{}",
45            JavaLangString::to_rust_string(&jvm, &trace).await.unwrap()
46        ))
47    } else {
48        Ok(result?)
49    }
50}
51
52async fn create_jvm<T>(stdout: T, start_type: &StartType<'_>, class_path: &[&Path]) -> anyhow::Result<Jvm>
53where
54    T: Sync + Send + Write + 'static,
55{
56    let runtime = Box::new(RuntimeImpl::new(stdout)) as Box<dyn Runtime>;
57
58    let bootstrap_class_loader = get_bootstrap_class_loader(runtime.clone());
59
60    let class_path_str = build_class_path(start_type, class_path)?;
61    let properties = [("java.class.path", class_path_str.as_str())].into_iter().collect();
62
63    Ok(Jvm::new(bootstrap_class_loader, move || runtime.current_task_id(), properties, None).await?)
64}
65
66fn build_class_path(start_type: &StartType<'_>, class_path: &[&Path]) -> anyhow::Result<String> {
67    let mut entries = Vec::new();
68    if let StartType::Jar(path) = start_type {
69        entries.push(path.as_os_str());
70    }
71    entries.extend(class_path.iter().map(|path| path.as_os_str()));
72
73    env::join_paths(entries)?
74        .into_string()
75        .map_err(|_| anyhow::anyhow!("Class path contains a non-UTF-8 path"))
76}
77
78async fn invoke_entrypoint<S>(jvm: &Jvm, start_type: &StartType<'_>, args: &[S]) -> Result<()>
79where
80    S: AsRef<str>,
81{
82    let main_class_name = match start_type {
83        StartType::Jar(x) => &get_jar_main_class(jvm, x).await?,
84        StartType::Class(x) => x.file_stem().unwrap().to_str().unwrap(),
85    };
86
87    let mut java_args = Vec::with_capacity(args.len());
88    for arg in args {
89        java_args.push(JavaLangString::from_rust_string(jvm, arg.as_ref()).await?);
90    }
91    let mut array = jvm.instantiate_array("Ljava/lang/String;", args.len()).await?;
92    jvm.store_array(&mut array, 0, java_args).await.unwrap();
93
94    let normalized_name = main_class_name.replace('.', "/");
95    let _: () = jvm
96        .invoke_static(&normalized_name, "main", "([Ljava/lang/String;)V", [JavaValue::Object(Some(array))])
97        .await?;
98
99    Ok(())
100}
101
102async fn get_jar_main_class(jvm: &Jvm, jar_path: &Path) -> Result<String> {
103    let filename = JavaLangString::from_rust_string(jvm, jar_path.to_str().unwrap()).await?;
104    let file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (filename,)).await?;
105    let jar_file = jvm.new_class("java/util/jar/JarFile", "(Ljava/io/File;)V", (file,)).await?;
106
107    let manifest = jvm
108        .invoke_virtual(&jar_file, "java/util/jar/JarFile", "getManifest", "()Ljava/util/jar/Manifest;", ())
109        .await?;
110    let attributes = jvm
111        .invoke_virtual(
112            &manifest,
113            "java/util/jar/Manifest",
114            "getMainAttributes",
115            "()Ljava/util/jar/Attributes;",
116            (),
117        )
118        .await?;
119
120    let main_class = jvm
121        .invoke_virtual(
122            &attributes,
123            "java/util/jar/Attributes",
124            "getValue",
125            "(Ljava/lang/String;)Ljava/lang/String;",
126            (JavaLangString::from_rust_string(jvm, "Main-Class").await?,),
127        )
128        .await?;
129
130    JavaLangString::to_rust_string(jvm, &main_class).await
131}
132
133#[cfg(test)]
134mod tests {
135    use std::{env, path::Path};
136
137    use super::{StartType, build_class_path};
138
139    #[test]
140    fn class_launch_classpath_preserves_order_and_empty_entries() {
141        assert_eq!(
142            build_class_path(
143                &StartType::Class(Path::new("Main")),
144                &[Path::new("classes"), Path::new(""), Path::new("lib/dependency.jar")],
145            )
146            .unwrap(),
147            env::join_paths(["classes", "", "lib/dependency.jar"]).unwrap().into_string().unwrap()
148        );
149    }
150
151    #[test]
152    fn jar_launch_classpath_has_no_trailing_separator_without_user_entries() {
153        assert_eq!(build_class_path(&StartType::Jar(Path::new("app.jar")), &[]).unwrap(), "app.jar");
154    }
155
156    #[test]
157    fn jar_library_api_preserves_explicit_user_classpath() {
158        assert_eq!(
159            build_class_path(&StartType::Jar(Path::new("app.jar")), &[Path::new("lib/dependency.jar")]).unwrap(),
160            env::join_paths(["app.jar", "lib/dependency.jar"]).unwrap().into_string().unwrap()
161        );
162    }
163
164    #[test]
165    fn empty_class_launch_has_no_bootstrap_entry_in_application_classpath() {
166        assert_eq!(build_class_path(&StartType::Class(Path::new("Main")), &[]).unwrap(), "");
167    }
168
169    #[cfg(unix)]
170    #[test]
171    fn classpath_rejects_non_utf8_entries() {
172        use std::{ffi::OsString, os::unix::ffi::OsStringExt, path::PathBuf};
173
174        let path = PathBuf::from(OsString::from_vec(vec![0xff]));
175        let error = build_class_path(&StartType::Class(Path::new("Main")), &[&path]).unwrap_err();
176
177        assert_eq!(error.to_string(), "Class path contains a non-UTF-8 path");
178    }
179}