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}