Add logging, error pretty print on rustjava

Author: dlunch

Cargo.lock

@@ -41,7 +41,9 @@ name = "rust_java"
 async-trait = { workspace = true }
 bytemuck = { workspace = true }
 
+anyhow = { workspace = true }
 clap = { version = "^4.5", features = ["derive"] }
+tracing-subscriber = { version = "^0.3", features = ["env-filter"] }
 
 jvm = { workspace = true }
 jvm_rust = { workspace = true }

Cargo.toml

@@ -5,7 +5,7 @@ mod runtime;
 use std::{io::Write, path::Path};
 
 use java_runtime::{RT_RUSTJAR, Runtime, get_bootstrap_class_loader};
-use jvm::{JavaValue, Jvm, Result, runtime::JavaLangString};
+use jvm::{JavaError, JavaValue, Jvm, Result, runtime::JavaLangString};
 
 use runtime::RuntimeImpl;
 
@@ -14,10 +14,43 @@ pub enum StartType<'a> {
     Class(&'a Path),
 }
 
-pub async fn run<T, S>(stdout: T, start_type: StartType<'_>, args: &[S], class_path: &[&Path]) -> Result<()>
+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(x) = result {
+        Err(match x {
+            JavaError::JavaException(x) => {
+                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, "printStackTrace", "(Ljava/io/PrintWriter;)V", (print_writer,))
+                    .await
+                    .unwrap();
+
+                let trace = jvm.invoke_virtual(&string_writer, "toString", "()Ljava/lang/String;", []).await.unwrap();
+
+                anyhow::anyhow!("Java Exception:\n{}", JavaLangString::to_rust_string(&jvm, &trace).await.unwrap())
+            }
+            JavaError::FatalError(x) => anyhow::anyhow!("Fatal error: {x}"),
+        })
+    } else {
+        Ok(result?)
+    }
+}
+
+async fn create_jvm<T>(stdout: T, start_type: &StartType<'_>, class_path: &[&Path]) -> Result<Jvm>
+where
+    T: Sync + Send + Write + 'static,
 {
     let runtime = Box::new(RuntimeImpl::new(stdout)) as Box<dyn Runtime>;
 
@@ -33,16 +66,21 @@ where
     let class_path_str = format!("{RT_RUSTJAR}:{class_path_str}");
     let properties = [("java.class.path", class_path_str.as_str())].into_iter().collect();
 
-    let jvm = Jvm::new(bootstrap_class_loader, move || runtime.current_task_id(), properties).await?;
+    Jvm::new(bootstrap_class_loader, move || runtime.current_task_id(), properties).await
+}
 
+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::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?);
+        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();

src/lib.rs

@@ -1,11 +1,10 @@
 use std::{
-    io,
+    io::{self, stderr},
     path::{Path, PathBuf},
 };
 
 use clap::{ArgGroup, Parser};
 
-use jvm::Result;
 use rust_java::{StartType, run};
 
 #[derive(Parser)]
@@ -19,7 +18,12 @@ struct Opts {
     args: Vec<String>,
 }
 
-pub fn main() -> Result<()> {
+pub fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_writer(stderr)
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .init();
+
     #[cfg(not(target_arch = "wasm32"))]
     let runtime = tokio::runtime::Runtime::new().unwrap();
     #[cfg(target_arch = "wasm32")]
@@ -28,7 +32,7 @@ pub fn main() -> Result<()> {
     runtime.block_on(async_main())
 }
 
-pub async fn async_main() -> Result<()> {
+pub async fn async_main() -> anyhow::Result<()> {
     let opts = Opts::parse();
 
     let start_type = if opts.main_class.is_some() {

src/main.rs

@@ -7,7 +7,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use jvm::Result;
 use rust_java::{StartType, run};
 
 struct Output {
@@ -24,7 +23,7 @@ impl io::Write for Output {
     }
 }
 
-pub async fn run_class(path: &Path, class_path: &[&Path], args: &[String]) -> Result<String> {
+pub async fn run_class(path: &Path, class_path: &[&Path], args: &[String]) -> anyhow::Result<String> {
     let output = Arc::new(Mutex::new(Vec::new()));
 
     run(Output { output: output.clone() }, StartType::Class(path), args, class_path).await?;
@@ -34,7 +33,7 @@ pub async fn run_class(path: &Path, class_path: &[&Path], args: &[String]) -> Re
     Ok(result)
 }
 
-pub async fn run_jar(jar_path: &Path, args: &[String]) -> Result<String> {
+pub async fn run_jar(jar_path: &Path, args: &[String]) -> anyhow::Result<String> {
     let output = Arc::new(Mutex::new(Vec::new()));
 
     run(Output { output: output.clone() }, StartType::Jar(jar_path), args, &[]).await?;