rustjava-runtime 0.3.5

A Java standard library implementation for RustJava
Documentation
use alloc::{format, vec, vec::Vec};

use jvm::{
    Array, ClassInstanceRef, Jvm, Result,
    runtime::{JavaIoInputStream, JavaLangString},
};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};

use crate::{
    FileType, RuntimeClassProto, RuntimeContext,
    classes::java::{
        lang::{Class, ClassLoader, String},
        net::{JarURLConnection, URL},
        util::jar::JarEntry,
    },
};

// class java.net.URLClassLoader
pub struct URLClassLoader;

impl URLClassLoader {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/net/URLClassLoader",
            parent_class: Some("java/lang/ClassLoader"), // TODO java.security.SecureClassLoader
            interfaces: vec![],
            methods: vec![
                JavaMethodProto::new(
                    "<init>",
                    "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
                    Self::init,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new(
                    "findClass",
                    "(Ljava/lang/String;)Ljava/lang/Class;",
                    Self::find_class,
                    MethodAccessFlags::PROTECTED,
                ),
                JavaMethodProto::new(
                    "findResource",
                    "(Ljava/lang/String;)Ljava/net/URL;",
                    Self::find_resource,
                    MethodAccessFlags::PUBLIC,
                ),
            ],
            fields: vec![JavaFieldProto::new("urls", "[Ljava/net/URL;", FieldAccessFlags::PRIVATE)],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        urls: ClassInstanceRef<Array<URL>>,
        parent: ClassInstanceRef<ClassLoader>,
    ) -> Result<()> {
        tracing::debug!("java.net.URLClassLoader::<init>({this:?}, {urls:?}, {parent:?})");

        if urls.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "urls is null").await);
        }
        let entries: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
        if entries.iter().any(|url| url.is_null()) {
            return Err(jvm.exception("java/lang/NullPointerException", "URL element is null").await);
        }

        let _: () = jvm
            .invoke_special(&this, "java/lang/ClassLoader", "<init>", "(Ljava/lang/ClassLoader;)V", (parent,))
            .await?;

        jvm.put_field(&mut this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;", urls)
            .await?;

        Ok(())
    }

    async fn find_class(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        name: ClassInstanceRef<String>,
    ) -> Result<ClassInstanceRef<Class>> {
        tracing::debug!("java.net.URLClassLoader::findClass({this:?}, {name:?})");

        if name.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
        }

        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;

        let resource_name = format!("{}.class", name_str.replace('.', "/"));
        let resource_name = JavaLangString::from_rust_string(jvm, &resource_name).await?;

        let resource: ClassInstanceRef<URL> = jvm
            .invoke_virtual(
                &this,
                "java/net/URLClassLoader",
                "findResource",
                "(Ljava/lang/String;)Ljava/net/URL;",
                (resource_name,),
            )
            .await?;
        if resource.is_null() {
            return Ok(None.into());
        }

        let stream = jvm
            .invoke_virtual(&resource, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
            .await?;
        let bytes = JavaIoInputStream::read_until_end(jvm, &stream).await?;

        let length = bytes.len() as i32;
        let mut bytes_java = jvm.instantiate_array("B", bytes.len()).await?;
        jvm.array_raw_buffer_mut(&mut bytes_java).await?.write(0, &bytes)?;

        let class = jvm
            .invoke_virtual(
                &this,
                "java/net/URLClassLoader",
                "defineClass",
                "(Ljava/lang/String;[BII)Ljava/lang/Class;",
                (name, bytes_java.clone(), 0, length),
            )
            .await?;

        Ok(class)
    }

    async fn find_resource(
        jvm: &Jvm,
        runtime: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        name: ClassInstanceRef<String>,
    ) -> Result<ClassInstanceRef<URL>> {
        tracing::debug!("java.net.URLClassLoader::findResource({this:?}, {name:?})");

        if name.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
        }

        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;

        let urls = jvm.get_field(&this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;").await?;
        let urls: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;

        for url in urls {
            let file: ClassInstanceRef<String> = jvm.invoke_virtual(&url, "java/net/URL", "getFile", "()Ljava/lang/String;", ()).await?;
            let path = jvm
                .invoke_static(
                    "org/rustjava/net/URLPath",
                    "decode",
                    "(Ljava/lang/String;)Ljava/lang/String;",
                    (file.clone(),),
                )
                .await?;
            let file = JavaLangString::to_rust_string(jvm, &file).await?;
            let path = JavaLangString::to_rust_string(jvm, &path).await?;

            let metadata = runtime.metadata(&path).await;
            if path.ends_with('/') || path.is_empty() || metadata.as_ref().is_ok_and(|metadata| metadata.r#type == FileType::Directory) {
                // directory
                let final_path = if path.is_empty() {
                    name_str.clone()
                } else if path.ends_with('/') {
                    format!("{path}{name_str}")
                } else {
                    format!("{path}/{name_str}")
                };

                if runtime.metadata(&final_path).await.is_ok() {
                    let final_path = JavaLangString::from_rust_string(jvm, &final_path).await?;
                    let final_path: ClassInstanceRef<String> = jvm
                        .invoke_static(
                            "org/rustjava/net/URLPath",
                            "encode",
                            "(Ljava/lang/String;)Ljava/lang/String;",
                            (final_path,),
                        )
                        .await?;
                    let new_url = jvm
                        .new_class(
                            "java/net/URL",
                            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
                            (
                                JavaLangString::from_rust_string(jvm, "file").await?,
                                JavaLangString::from_rust_string(jvm, "").await?,
                                final_path,
                            ),
                        )
                        .await?;

                    return Ok(new_url.into());
                }
            } else if metadata.is_err() {
                continue;
            } else {
                // treat as jar
                let name_str = name_str.trim_start_matches('/');
                let entry = JavaLangString::from_rust_string(jvm, name_str).await?;
                let entry = jvm
                    .invoke_static("org/rustjava/net/URLPath", "encode", "(Ljava/lang/String;)Ljava/lang/String;", (entry,))
                    .await?;
                let entry = JavaLangString::to_rust_string(jvm, &entry).await?;
                let jar_url_str = format!("jar:file:{file}!/{entry}"); // TODO url might not be file
                let jar_url = JavaLangString::from_rust_string(jvm, &jar_url_str).await?;
                let jar_url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (jar_url,)).await?;
                let connection: ClassInstanceRef<JarURLConnection> = jvm
                    .invoke_virtual(&jar_url, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
                    .await?;

                let entry: ClassInstanceRef<JarEntry> = jvm
                    .invoke_virtual(&connection, "java/net/JarURLConnection", "getJarEntry", "()Ljava/util/jar/JarEntry;", ())
                    .await?;

                if !entry.is_null() {
                    return Ok(jar_url.into());
                }
            }
        }

        Ok(None.into())
    }
}