fix bugs

Author: owjs3901

crates/vespera/src/multipart.rs

@@ -498,11 +498,16 @@ fn tiny_scalar_limit(limit_bytes: Option<usize>) -> usize {
 
 /// Parse a string as a boolean using clap-style conventions.
 ///
+/// Surrounding ASCII whitespace is ignored, so a multipart text value that
+/// arrives with incidental padding (e.g. a trailing newline) parses like the
+/// trimmed token — matching the numeric field impls, which `text.trim().parse()`.
+///
 /// Accepted truthy values: `true`, `yes`, `y`, `1`, `on`
 /// Accepted falsy  values: `false`, `no`, `n`, `0`, `off`
 fn str_to_bool(s: &str) -> Option<bool> {
     const TRUTHY: [&str; 5] = ["true", "yes", "y", "1", "on"];
     const FALSY: [&str; 5] = ["false", "no", "n", "0", "off"];
+    let s = s.trim();
     if TRUTHY.iter().any(|t| s.eq_ignore_ascii_case(t)) {
         Some(true)
     } else if FALSY.iter().any(|f| s.eq_ignore_ascii_case(f)) {

crates/vespera/src/multipart/tests.rs

@@ -27,6 +27,23 @@ fn test_str_to_bool_invalid() {
     }
 }
 
+#[test]
+fn test_str_to_bool_trims_surrounding_whitespace() {
+    // Multipart text values can arrive with incidental surrounding whitespace
+    // (e.g. a trailing newline from a client); bool must tolerate it exactly as
+    // the numeric field impls do (`text.trim().parse()`), so a padded token
+    // parses like the bare token instead of being rejected.
+    assert_eq!(str_to_bool("  true  "), Some(true));
+    assert_eq!(str_to_bool("true\n"), Some(true));
+    assert_eq!(str_to_bool("\tyes\r\n"), Some(true));
+    assert_eq!(str_to_bool(" false"), Some(false));
+    assert_eq!(str_to_bool("off\n"), Some(false));
+    // Trim only touches the ends — internal whitespace stays invalid, and a
+    // whitespace-only value is still `None`.
+    assert_eq!(str_to_bool("tr ue"), None);
+    assert_eq!(str_to_bool("   "), None);
+}
+
 // ─── Display tests for all error variants ───────────────────────────
 
 #[test]

crates/vespera_jni/src/jni_buf.rs

@@ -63,7 +63,7 @@ pub fn read_byte_array_region(
     //   path) or the exact positive `InputStream.read(byte[])` count after
     //   checking it does not exceed the fixed streaming buffer length.
     // * The destination is `vec`'s reserved-but-uninitialised capacity
-    //   (`with_capacity(len)` reserved exactly `len` bytes).  Only a raw
+    //   (`try_reserve_exact(len)` reserved exactly `len` bytes).  Only a raw
     //   `*mut jbyte` is passed to JNI — no `&mut [i8]` over uninitialised
     //   memory is created.  `u8` and `jbyte` (`i8`) share size/alignment.
     unsafe {

crates/vespera_jni/src/jni_impl.rs

@@ -10,7 +10,7 @@ use futures_util::FutureExt;
 use jni::EnvUnowned;
 use jni::errors::ThrowRuntimeExAndDefault;
 use jni::objects::{JByteArray, JClass, JObject};
-use jni::sys::{jbyteArray, jint};
+use jni::sys::jbyteArray;
 
 use crate::daemon_env::with_cached_daemon_env;
 use crate::streaming_closures::{
@@ -24,6 +24,13 @@ use crate::streaming_closures::{
 mod streaming_buffer;
 use streaming_buffer::{PullPushBuffers, mark_streaming_buffer_reusable};
 
+// Runtime / streaming configuration JNI hooks (seeded from
+// `VesperaBridge.init()` before the first dispatch) live in a sidecar
+// module so this file stays focused on the per-request dispatch symbols.
+#[path = "jni_impl_config.rs"]
+mod config;
+pub use config::{runtime_worker_threads, streaming_chunk_size};
+
 /// Multi-threaded Tokio runtime shared across all JNI calls.
 ///
 /// Worker thread count defaults to Tokio's heuristic (number of
@@ -41,11 +48,6 @@ pub static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
         .expect("failed to create Tokio runtime")
 });
 
-const MIN_RUNTIME_WORKERS: usize = 1;
-const MAX_RUNTIME_WORKERS: usize = 1024;
-
-static RUNTIME_WORKER_THREADS: std::sync::OnceLock<Option<usize>> = std::sync::OnceLock::new();
-
 /// Cap on each per-thread sync runtime's blocking pool.
 ///
 /// [`block_on_sync_runtime`] builds ONE current-thread runtime per calling
@@ -200,106 +202,6 @@ use support::{
     setup_stream_with_header, throw_streaming_abort,
 };
 
-/// Worker thread count for the shared [`RUNTIME`], resolved once
-/// (first hit wins, then fixed for the process lifetime):
-///
-/// 1. [`set_runtime_worker_threads`] called before the runtime is
-///    first used (the `configureRuntime0` JNI hook from
-///    `VesperaBridge.init()` lands here)
-/// 2. `VESPERA_RUNTIME_WORKERS` environment variable
-/// 3. `None` — Tokio's default (number of logical CPUs)
-///
-/// Values are clamped to `[1, 1024]`.
-#[must_use]
-pub fn runtime_worker_threads() -> Option<usize> {
-    *RUNTIME_WORKER_THREADS.get_or_init(|| {
-        std::env::var("VESPERA_RUNTIME_WORKERS")
-            .ok()
-            .and_then(|raw| raw.trim().parse::<usize>().ok())
-            .map(|v| v.clamp(MIN_RUNTIME_WORKERS, MAX_RUNTIME_WORKERS))
-    })
-}
-
-/// Override the shared runtime's worker thread count **before the
-/// first dispatch**.  Returns `false` when the value was already
-/// fixed.  Clamped to `[1, 1024]`.
-pub fn set_runtime_worker_threads(workers: usize) -> bool {
-    RUNTIME_WORKER_THREADS
-        .set(Some(
-            workers.clamp(MIN_RUNTIME_WORKERS, MAX_RUNTIME_WORKERS),
-        ))
-        .is_ok()
-}
-
-/// `com.devfive.vespera.bridge.VesperaBridge.configureRuntime0(int) -> void`
-///
-/// Seeds the shared Tokio runtime's worker thread count **before
-/// the first dispatch**.  Values `<= 0` leave the setting
-/// untouched (env var / Tokio default applies).  Calls after the
-/// configuration is fixed are silently ignored.
-#[unsafe(no_mangle)]
-pub extern "system" fn Java_com_devfive_vespera_bridge_VesperaBridge_configureRuntime0<'local>(
-    _unowned_env: EnvUnowned<'local>,
-    _class: JClass<'local>,
-    worker_threads: jint,
-) {
-    // Defensive `catch_unwind`: this body cannot panic today, but it is
-    // an `extern "system"` JNI symbol, so guard it for consistency with
-    // the dispatch symbols — an unwind must never cross the FFI boundary.
-    let _ = std::panic::catch_unwind(|| {
-        if let Ok(workers) = usize::try_from(worker_threads)
-            && workers > 0
-        {
-            let _ = set_runtime_worker_threads(workers);
-        }
-    });
-}
-
-/// Per-chunk buffer size for streaming dispatches.
-///
-/// Resolved once per process by
-/// [`vespera_inprocess::streaming_chunk_bytes`] (default 256 KiB;
-/// override via the `VESPERA_STREAMING_CHUNK_BYTES` env var or the
-/// `configureStreaming0` JNI setter called from
-/// `VesperaBridge.init()`).  Large enough to amortise JNI call
-/// overhead, small enough to keep memory bounded for multi-GB
-/// streams.  Subsequent calls are a single atomic load.
-pub fn streaming_chunk_size() -> usize {
-    vespera_inprocess::streaming_chunk_bytes()
-}
-
-/// `com.devfive.vespera.bridge.VesperaBridge.configureStreaming0(int, int) -> void`
-///
-/// Seeds the process-wide streaming configuration **before the
-/// first dispatch**.  Values `<= 0` leave the corresponding
-/// setting untouched (env var / default applies).  Calls after
-/// the configuration is fixed (first dispatch already ran, or a
-/// previous call set it) are silently ignored — the JNI side has
-/// no use for the failure signal beyond logging, which Java owns.
-#[unsafe(no_mangle)]
-pub extern "system" fn Java_com_devfive_vespera_bridge_VesperaBridge_configureStreaming0<'local>(
-    _unowned_env: EnvUnowned<'local>,
-    _class: JClass<'local>,
-    chunk_bytes: jint,
-    channel_capacity: jint,
-) {
-    // Defensive `catch_unwind` — see `configureRuntime0`: keep every JNI
-    // `extern "system"` symbol panic-safe even though this body cannot
-    // panic with the current setters.
-    let _ = std::panic::catch_unwind(|| {
-        if let Ok(bytes) = usize::try_from(chunk_bytes)
-            && bytes > 0
-        {
-            let _ = vespera_inprocess::set_streaming_chunk_bytes(bytes);
-        }
-        if let Ok(slots) = usize::try_from(channel_capacity)
-            && slots > 0
-        {
-            let _ = vespera_inprocess::set_streaming_channel_capacity(slots);
-        }
-    });
-}
-
 /// `com.devfive.vespera.bridge.VesperaBridge.dispatchBytes(byte[]) -> byte[]`
 ///
 /// **Synchronous** binary wire-format JNI entry point.  Blocks the

crates/vespera_jni/src/jni_impl_config.rs

@@ -0,0 +1,115 @@
+//! Runtime / streaming configuration JNI hooks.
+//!
+//! These symbols are seeded from `VesperaBridge.init()` **before the first
+//! dispatch** and then fixed for the process lifetime.  They are split out of
+//! `jni_impl.rs` (which owns the per-request dispatch symbols) so each file
+//! keeps a single concern — and stays within the 1000-line source cap.
+
+use jni::EnvUnowned;
+use jni::objects::JClass;
+use jni::sys::jint;
+
+const MIN_RUNTIME_WORKERS: usize = 1;
+const MAX_RUNTIME_WORKERS: usize = 1024;
+
+static RUNTIME_WORKER_THREADS: std::sync::OnceLock<Option<usize>> = std::sync::OnceLock::new();
+
+/// Worker thread count for the shared [`RUNTIME`](super::RUNTIME), resolved once
+/// (first hit wins, then fixed for the process lifetime):
+///
+/// 1. [`set_runtime_worker_threads`] called before the runtime is
+///    first used (the `configureRuntime0` JNI hook from
+///    `VesperaBridge.init()` lands here)
+/// 2. `VESPERA_RUNTIME_WORKERS` environment variable
+/// 3. `None` — Tokio's default (number of logical CPUs)
+///
+/// Values are clamped to `[1, 1024]`.
+#[must_use]
+pub fn runtime_worker_threads() -> Option<usize> {
+    *RUNTIME_WORKER_THREADS.get_or_init(|| {
+        std::env::var("VESPERA_RUNTIME_WORKERS")
+            .ok()
+            .and_then(|raw| raw.trim().parse::<usize>().ok())
+            .map(|v| v.clamp(MIN_RUNTIME_WORKERS, MAX_RUNTIME_WORKERS))
+    })
+}
+
+/// Override the shared runtime's worker thread count **before the
+/// first dispatch**.  Returns `false` when the value was already
+/// fixed.  Clamped to `[1, 1024]`.
+pub fn set_runtime_worker_threads(workers: usize) -> bool {
+    RUNTIME_WORKER_THREADS
+        .set(Some(
+            workers.clamp(MIN_RUNTIME_WORKERS, MAX_RUNTIME_WORKERS),
+        ))
+        .is_ok()
+}
+
+/// `com.devfive.vespera.bridge.VesperaBridge.configureRuntime0(int) -> void`
+///
+/// Seeds the shared Tokio runtime's worker thread count **before
+/// the first dispatch**.  Values `<= 0` leave the setting
+/// untouched (env var / Tokio default applies).  Calls after the
+/// configuration is fixed are silently ignored.
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_com_devfive_vespera_bridge_VesperaBridge_configureRuntime0<'local>(
+    _unowned_env: EnvUnowned<'local>,
+    _class: JClass<'local>,
+    worker_threads: jint,
+) {
+    // Defensive `catch_unwind`: this body cannot panic today, but it is
+    // an `extern "system"` JNI symbol, so guard it for consistency with
+    // the dispatch symbols — an unwind must never cross the FFI boundary.
+    let _ = std::panic::catch_unwind(|| {
+        if let Ok(workers) = usize::try_from(worker_threads)
+            && workers > 0
+        {
+            let _ = set_runtime_worker_threads(workers);
+        }
+    });
+}
+
+/// Per-chunk buffer size for streaming dispatches.
+///
+/// Resolved once per process by
+/// [`vespera_inprocess::streaming_chunk_bytes`] (default 256 KiB;
+/// override via the `VESPERA_STREAMING_CHUNK_BYTES` env var or the
+/// `configureStreaming0` JNI setter called from
+/// `VesperaBridge.init()`).  Large enough to amortise JNI call
+/// overhead, small enough to keep memory bounded for multi-GB
+/// streams.  Subsequent calls are a single atomic load.
+pub fn streaming_chunk_size() -> usize {
+    vespera_inprocess::streaming_chunk_bytes()
+}
+
+/// `com.devfive.vespera.bridge.VesperaBridge.configureStreaming0(int, int) -> void`
+///
+/// Seeds the process-wide streaming configuration **before the
+/// first dispatch**.  Values `<= 0` leave the corresponding
+/// setting untouched (env var / default applies).  Calls after
+/// the configuration is fixed (first dispatch already ran, or a
+/// previous call set it) are silently ignored — the JNI side has
+/// no use for the failure signal beyond logging, which Java owns.
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_com_devfive_vespera_bridge_VesperaBridge_configureStreaming0<'local>(
+    _unowned_env: EnvUnowned<'local>,
+    _class: JClass<'local>,
+    chunk_bytes: jint,
+    channel_capacity: jint,
+) {
+    // Defensive `catch_unwind` — see `configureRuntime0`: keep every JNI
+    // `extern "system"` symbol panic-safe even though this body cannot
+    // panic with the current setters.
+    let _ = std::panic::catch_unwind(|| {
+        if let Ok(bytes) = usize::try_from(chunk_bytes)
+            && bytes > 0
+        {
+            let _ = vespera_inprocess::set_streaming_chunk_bytes(bytes);
+        }
+        if let Ok(slots) = usize::try_from(channel_capacity)
+            && slots > 0
+        {
+            let _ = vespera_inprocess::set_streaming_channel_capacity(slots);
+        }
+    });
+}

crates/vespera_jni/src/jni_impl_runtime_config_tests.rs

@@ -1,4 +1,4 @@
-use super::{runtime_worker_threads, set_runtime_worker_threads};
+use super::config::{runtime_worker_threads, set_runtime_worker_threads};
 
 /// One test owns the process-global `OnceLock`: setter wins,
 /// clamping applies, and later writes are rejected.