Update dependency gradle to v8.10

Enable LTO for release build in Cargo.toml

.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        java: [ 21 ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: |
+            reqwest-jni
+      - run: cargo install cross
+      - name: set up JDK ${{ matrix.java }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: ${{ matrix.java }}
+          distribution: zulu
+          cache: "gradle"
+      - name: Run Build
+        run: ./gradlew shadowJar

.github/workflows/publish-maven.yml

@@ -12,17 +12,18 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
         with:
           workspaces: |
             reqwest-jni
       - run: cargo install cross
       - name: set up JDK
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
-          java-version: 17
-          distribution: temurin
+          java-version: 21
+          distribution: zulu
           check-latest: true
           cache: "gradle"
       - name: Save Private Key

README.md

@@ -1,2 +1,2 @@
 # reqwest4j
-WIP Java bindings to Reqwest with jni-rs for use in Piped's backend!
+Java bindings to Reqwest with jni-rs for use in Piped's backend!

build.gradle

@@ -3,7 +3,7 @@ plugins {
     id "maven-publish"
     id "signing"
     id "fr.stardustenterprises.rust.importer" version "3.2.5"
-    id 'com.github.johnrengelman.shadow' version '7.1.2'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
 }
 
 repositories {
@@ -17,14 +17,14 @@ dependencies {
 // javac -h
 tasks.register('generateJniHeaders', JavaCompile) {
     classpath = sourceSets.main.compileClasspath
-    destinationDir file("${buildDir}/generated/jni")
+    destinationDir file("${layout.buildDirectory}/generated/jni")
     source = sourceSets.main.java
     options.compilerArgs += [
-            '-h', file("${buildDir}/generated/jni"),
-            '-d', file("${buildDir}/generated/jni-classes"),
+            '-h', file("${layout.buildDirectory}/generated/jni"),
+            '-d', file("${layout.buildDirectory}/generated/jni-classes"),
     ]
     doLast {
-        delete file("${buildDir}/generated/jni-classes")
+        delete file("${layout.buildDirectory}/generated/jni-classes")
     }
 }
 
@@ -36,6 +36,8 @@ rustImport {
 java {
     withSourcesJar()
     withJavadocJar()
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
 }
 
 signing {
@@ -43,9 +45,7 @@ signing {
 }
 
 group = 'rocks.kavin'
-version = '1.0.1'
-sourceCompatibility = JavaVersion.VERSION_17
-targetCompatibility = JavaVersion.VERSION_17
+version = '1.0.14'
 
 publishing {
     repositories {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://downloads.gradle.org/distributions/gradle-7.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -83,10 +85,9 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,10 +134,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -144,7 +148,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +156,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -197,11 +201,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 

renovate.json

@@ -0,0 +1,17 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": [
+        "config:base",
+        "group:recommended"
+    ],
+    "ignorePresets": [
+        ":prHourlyLimit2"
+    ],
+    "packageRules": [
+        {
+            "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
+            "automerge": true,
+            "platformAutomerge": true
+        }
+    ]
+}

reqwest-jni/Cargo.toml

@@ -6,10 +6,12 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-jni = "0.20.0"
-reqwest = {version = "0.11.14", features = ["rustls-tls", "stream", "brotli", "gzip"], default-features = false}
-tokio = {version = "1.24.2", features = ["full"]}
-lazy_static = "1.4.0"
+jni = "0.21.1"
+reqwest = {version = "0.12.4", features = ["rustls-tls", "stream", "brotli", "gzip", "socks"], default-features = false}
+tokio = {version = "1.37.0", features = ["rt-multi-thread", "time"], default-features = false}
 
 [lib]
 crate-type = ["cdylib"]
+
+[profile.release]
+lto = true

reqwest-jni/build.gradle.kts

@@ -8,4 +8,5 @@ rust {
 
     targets += target("aarch64-unknown-linux-gnu", "libreqwest.so")
     targets += target("x86_64-unknown-linux-gnu", "libreqwest.so")
+    targets += target("x86_64-pc-windows-gnu", "libreqwest.dll")
 }

reqwest-jni/src/lib.rs

@@ -1,61 +1,115 @@
 use std::collections::HashMap;
+use std::sync::{Arc, OnceLock};
+use std::time::Duration;
 
+use jni::objects::{JByteArray, JClass, JMap, JObject, JString};
+use jni::sys::jobject;
 use jni::JNIEnv;
-use jni::objects::{JClass, JMap, JObject, JString};
-use jni::sys::{jbyteArray, jobject};
-use lazy_static::lazy_static;
 use reqwest::{Client, Method, Url};
 use tokio::runtime::Runtime;
 
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
+static RUNTIME: OnceLock<Runtime> = OnceLock::new();
+static CLIENT: OnceLock<Client> = OnceLock::new();
 
-lazy_static! {
-    static ref RUNTIME: Runtime = Runtime::new().unwrap();
-    static ref CLIENT: Client = Client::builder()
-        .user_agent("Mozilla/5.0 (Windows NT 10.0; rv:102.0) Gecko/20100101 Firefox/102.0")
+#[no_mangle]
+pub extern "system" fn Java_rocks_kavin_reqwest4j_ReqwestUtils_init(
+    mut env: JNIEnv,
+    _: JClass,
+    proxy: JString,
+    user: JString,
+    pass: JString,
+) {
+    let builder = Client::builder()
+        .user_agent("Mozilla/5.0 (Windows NT 10.0; rv:102.0) Gecko/20100101 Firefox/102.0");
+
+    let builder = match env.get_string(&proxy) {
+        Ok(proxy) => {
+            let proxy = proxy.to_str().unwrap();
+            let proxy = reqwest::Proxy::all(proxy).unwrap();
+            let proxy = match env.get_string(&user) {
+                Ok(user) => {
+                    let user = user.to_str().unwrap();
+                    let pass = env.get_string(&pass).unwrap();
+                    let pass = pass.to_str().unwrap();
+                    proxy.basic_auth(user, pass)
+                }
+                Err(_) => proxy,
+            };
+            builder.proxy(proxy)
+        }
+        Err(_) => builder,
+    };
+
+    let client = builder
+        // timeout for establishing connection
+        .connect_timeout(Duration::from_secs(10))
+        // timeout for entire request, till body is read
+        .timeout(Duration::from_secs(30))
         .build()
         .unwrap();
+    CLIENT.set(client).unwrap();
+    RUNTIME.set(Runtime::new().unwrap()).unwrap();
 }
 
 #[no_mangle]
 pub extern "system" fn Java_rocks_kavin_reqwest4j_ReqwestUtils_fetch(
-    env: JNIEnv,
+    mut env: JNIEnv,
     _: JClass,
     url: JString,
     method: JString,
-    body: jbyteArray,
+    body: JByteArray,
     headers: JObject,
 ) -> jobject {
-
     // set method, url, body, headers
-    let method = Method::from_bytes(env.get_string(method).unwrap().to_bytes()).unwrap();
+    let method = Method::from_bytes(env.get_string(&method).unwrap().to_bytes()).unwrap();
 
-    let url = &env.get_string(url).unwrap();
+    let url = &env.get_string(&url).unwrap();
     let url = url.to_str();
 
     if url.is_err() {
-        env.throw_new("java/lang/IllegalArgumentException", "Invalid URL provided, couldn't get string as UTF-8").unwrap();
+        env.throw_new(
+            "java/lang/IllegalArgumentException",
+            "Invalid URL provided, couldn't get string as UTF-8",
+        )
+        .unwrap();
         return JObject::null().into_raw();
     }
 
     let url = Url::parse(url.unwrap()).unwrap();
     let body = env.convert_byte_array(body).unwrap_or_default();
-    let headers: JMap = JMap::from_env(&env, headers).unwrap();
-    let headers = headers.iter().unwrap().fold(HashMap::new(), |mut headers, (key, value)| {
+    let java_headers: JMap = JMap::from_env(&mut env, &headers).unwrap();
+    let mut java_headers = java_headers.iter(&mut env).unwrap();
+    let mut headers = HashMap::new();
+    while let Some((key, value)) = java_headers.next(&mut env).unwrap() {
         headers.insert(
-            env.get_string(JString::from(key)).unwrap().to_str().unwrap().to_string(),
-            env.get_string(JString::from(value)).unwrap().to_str().unwrap().to_string(),
+            env.get_string(&JString::from(key))
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_string(),
+            env.get_string(&JString::from(value))
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_string(),
         );
-        headers
-    });
+    }
 
-    let request = CLIENT.request(method, url);
+    let client = CLIENT.get();
 
-    let request = headers.into_iter().fold(request, |request, (key, value)| {
-        request.header(key, value)
-    });
+    if client.is_none() {
+        env.throw_new("java/lang/IllegalStateException", "Client not initialized")
+            .unwrap();
+        return JObject::null().into_raw();
+    }
+
+    let client = client.unwrap();
+
+    let request = client.request(method, url);
+
+    let request = headers
+        .into_iter()
+        .fold(request, |request, (key, value)| request.header(key, value));
 
     let request = if body.is_empty() {
         request
@@ -63,52 +117,113 @@ pub extern "system" fn Java_rocks_kavin_reqwest4j_ReqwestUtils_fetch(
         request.body(body)
     };
 
-    // send request
-    let response = RUNTIME.block_on(async {
-        request.send().await.unwrap()
-    });
+    // `JNIEnv` cannot be sent between threads safely
+    let jvm = env.get_java_vm().unwrap();
+    let jvm = Arc::new(jvm);
 
-    // get response
-    let status = response.status().as_u16() as i32;
+    // create CompletableFuture
+    let _future = env
+        .new_object("java/util/concurrent/CompletableFuture", "()V", &[])
+        .unwrap();
+    let future = env.new_global_ref(&_future).unwrap();
+    let future = Arc::new(future);
 
-    let headers = env.new_object("java/util/HashMap", "()V", &[]).unwrap();
-    let headers: JMap = JMap::from_env(&env, headers).unwrap();
+    let runtime = RUNTIME.get().unwrap();
 
-    response.headers().iter().for_each(|(key, value)| {
-        let key = env.new_string(key.as_str()).unwrap();
-        let value = env.new_string(value.to_str().unwrap()).unwrap();
-        headers.put(JObject::from(key), JObject::from(value)).unwrap();
-    });
+    // send request in a async task
+    {
+        let jvm = Arc::clone(&jvm);
+        let future = Arc::clone(&future);
 
-    let final_url = response.url().to_string();
-    let final_url = env.new_string(final_url).unwrap();
+        runtime.spawn(async move {
+            // send request
+            let response = request.send().await;
 
-    let body = RUNTIME.block_on(async {
-        response.bytes().await.unwrap().to_vec()
-    });
+            match response {
+                Ok(response) => {
+                    // get response
+                    let status = response.status().as_u16() as i32;
 
+                    let final_url = response.url().to_string();
 
-    let body = env.byte_array_from_slice(&body).unwrap();
-    let body = unsafe { JObject::from_raw(body) };
+                    let response_headers = response.headers().clone();
 
-    // return response
-    let response = env.new_object("rocks/kavin/reqwest4j/Response", "(ILjava/util/Map;[BLjava/lang/String;)V", &[
-        status.into(),
-        headers.into(),
-        body.into(),
-        final_url.into(),
-    ]).unwrap();
+                    let body = response.bytes().await.unwrap_or_default().to_vec();
 
-    response.into_raw()
-}
+                    // send response in a blocking task
+                    runtime.spawn_blocking(move || {
+                        let mut env = jvm.attach_current_thread().unwrap();
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+                        let final_url = env.new_string(final_url).unwrap();
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+                        let body = env.byte_array_from_slice(&body).unwrap();
+
+                        let headers = env.new_object("java/util/HashMap", "()V", &[]).unwrap();
+                        let headers: JMap = JMap::from_env(&mut env, &headers).unwrap();
+
+                        response_headers.iter().for_each(|(key, value)| {
+                            let key = env.new_string(key.as_str()).unwrap();
+                            let value = env.new_string(value.to_str().unwrap()).unwrap();
+                            headers
+                                .put(&mut env, &JObject::from(key), &JObject::from(value))
+                                .unwrap();
+                        });
+
+                        // return response to CompletableFuture
+                        let response = env
+                            .new_object(
+                                "rocks/kavin/reqwest4j/Response",
+                                "(ILjava/util/Map;[BLjava/lang/String;)V",
+                                &[
+                                    status.into(),
+                                    (&headers).into(),
+                                    (&body).into(),
+                                    (&final_url).into(),
+                                ],
+                            )
+                            .unwrap();
+
+                        let future = future.as_obj();
+                        env.call_method(
+                            future,
+                            "complete",
+                            "(Ljava/lang/Object;)Z",
+                            &[(&response).into()],
+                        )
+                        .unwrap();
+                    });
+                }
+                Err(error) => {
+                    // send error in a blocking task
+                    runtime.spawn_blocking(move || {
+                        let mut env = jvm.attach_current_thread().unwrap();
+
+                        let error = error.to_string();
+                        let error = env.new_string(error).unwrap();
+                        // create Exception
+                        let exception = env
+                            .new_object(
+                                "java/lang/Exception",
+                                "(Ljava/lang/String;)V",
+                                &[(&error).into()],
+                            )
+                            .unwrap();
+
+                        let future = future.as_obj();
+
+                        // pass error to CompletableFuture
+                        env.call_method(
+                            future,
+                            "completeExceptionally",
+                            "(Ljava/lang/Throwable;)Z",
+                            &[(&exception).into()],
+                        )
+                        .unwrap();
+                    });
+                }
+            }
+        });
     }
+
+    _future.into_raw()
 }

src/main/java/rocks/kavin/reqwest4j/ReqwestUtils.java

@@ -1,42 +1,61 @@
 package rocks.kavin.reqwest4j;
 
 import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 
 public class ReqwestUtils {
 
     static {
-        String arch;
+        String arch = switch (System.getProperty("os.arch")) {
+            case "aarch64" -> "aarch64";
+            case "amd64" -> "x86_64";
+            default -> throw new RuntimeException("Unsupported architecture");
+        };
 
-        switch (System.getProperty("os.arch")) {
-            case "aarch64":
-                arch = "aarch64";
-                break;
-            case "amd64":
-                arch = "x86_64";
-                break;
-            default:
-                throw new RuntimeException("Unsupported architecture");
+        String os = System.getProperty("os.name").toLowerCase();
+
+        String extension;
+        String native_folder;
+
+        if (os.contains("win")) {
+            extension = ".dll";
+            native_folder = "windows";
+        } else if (os.contains("linux")) {
+            extension = ".so";
+            native_folder = "linux";
+        } else {
+            throw new RuntimeException("OS not supported");
         }
 
-        String fileName =
-                System.getProperty("java.io.tmpdir") +
-                        File.separatorChar +
-                        "libreqwest_" + System.currentTimeMillis() + ".so";
+        File nativeFile;
 
-        final var cl = ReqwestUtils.class.getClassLoader();
-
-        try (var stream = cl.getResourceAsStream("META-INF/natives/linux/" + arch + "/libreqwest.so")) {
-            stream.transferTo(new java.io.FileOutputStream(fileName));
+        try {
+            nativeFile = File.createTempFile("libreqwest", extension);
+            nativeFile.deleteOnExit();
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
 
-        System.load(fileName);
+        final var cl = ReqwestUtils.class.getClassLoader();
+
+        try (
+                var stream = cl.getResourceAsStream("META-INF/natives/" + native_folder + "/" + arch + "/libreqwest" + extension);
+                var fileOutputStream = new FileOutputStream(nativeFile)
+        ) {
+            stream.transferTo(fileOutputStream);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        System.load(nativeFile.getAbsolutePath());
     }
 
-    public static native Response fetch(String url, String method, byte[] body,
-                                        Map<String, String> headers);
+    public static native void init(String proxy, String user, String pass);
+
+    public static native CompletableFuture<Response> fetch(String url, String method, byte[] body,
+                                                           Map<String, String> headers);
 
 }