Optimize jni

Author: owjs3901

benches/compile-bench-runner/src/main.rs

@@ -58,12 +58,17 @@ fn parse_args() -> Args {
     };
     let mut it = env::args().skip(1);
     while let Some(arg) = it.next() {
-        let mut next = |flag: &str| it.next().unwrap_or_else(|| fatal(&format!("{flag} needs a value")));
+        let mut next = |flag: &str| {
+            it.next()
+                .unwrap_or_else(|| fatal(&format!("{flag} needs a value")))
+        };
         match arg.as_str() {
             "--target" => a.target = next("--target"),
             "--pass" => a.pass = next("--pass"),
             "--runs" => {
-                a.runs = next("--runs").parse().unwrap_or_else(|_| fatal("--runs must be an integer"));
+                a.runs = next("--runs")
+                    .parse()
+                    .unwrap_or_else(|_| fatal("--runs must be an integer"));
             }
             "--save-baseline" => a.save_baseline = Some(next("--save-baseline")),
             "--baseline" => a.baseline = Some(next("--baseline")),
@@ -110,7 +115,16 @@ fn measure_once(target: &str, pass: &str) -> Option<f64> {
     // Force a full re-expansion of the fixture lib (deps stay built).
     let _ = cargo().args(["clean", "-p", target]).status();
     let out = cargo()
-        .args(["rustc", "--quiet", "-p", target, "--lib", "--", "-Z", "time-passes"])
+        .args([
+            "rustc",
+            "--quiet",
+            "-p",
+            target,
+            "--lib",
+            "--",
+            "-Z",
+            "time-passes",
+        ])
         .output()
         .ok()?;
     let stderr = String::from_utf8_lossy(&out.stderr);
@@ -166,7 +180,11 @@ fn main() {
                 eprintln!("  run {:>2}: {t:.4}s", i + 1);
                 samples.push(t);
             }
-            None => eprintln!("  run {:>2}: pass `{}` not found in output", i + 1, args.pass),
+            None => eprintln!(
+                "  run {:>2}: pass `{}` not found in output",
+                i + 1,
+                args.pass
+            ),
         }
     }
     if samples.is_empty() {
@@ -175,8 +193,16 @@ fn main() {
 
     samples.sort_by(|a, b| a.partial_cmp(b).unwrap());
     let med0 = median(&samples);
-    let clean: Vec<f64> = samples.iter().copied().filter(|&t| t <= med0 * 3.0).collect();
-    let clean = if clean.is_empty() { samples.clone() } else { clean };
+    let clean: Vec<f64> = samples
+        .iter()
+        .copied()
+        .filter(|&t| t <= med0 * 3.0)
+        .collect();
+    let clean = if clean.is_empty() {
+        samples.clone()
+    } else {
+        clean
+    };
 
     let min = clean[0];
     let med = median(&clean);
@@ -209,8 +235,7 @@ fn main() {
         let path = baselines_dir().join(format!("{name}.txt"));
         match fs::read_to_string(&path) {
             Ok(s) => {
-                let mut base: Vec<f64> =
-                    s.lines().filter_map(|l| l.trim().parse().ok()).collect();
+                let mut base: Vec<f64> = s.lines().filter_map(|l| l.trim().parse().ok()).collect();
                 if base.is_empty() {
                     eprintln!("   baseline `{name}` is empty");
                 } else {

benches/macro-compile-bench/src/models/schemas.rs

@@ -171,12 +171,21 @@ pub struct ErrorBody {
 impl<T: Serialize> Paginated<T> {
     /// One empty page — keeps handlers free of `T` construction.
     pub fn empty() -> Self {
-        Self { items: Vec::new(), total: 0, page: 1, per_page: 20 }
+        Self {
+            items: Vec::new(),
+            total: 0,
+            page: 1,
+            per_page: 20,
+        }
     }
 }
 
 impl<T: Serialize> ApiResponse<T> {
     pub fn ok(data: T) -> Self {
-        Self { data, success: true, message: None }
+        Self {
+            data,
+            success: true,
+            message: None,
+        }
     }
 }

crates/vespera/src/multipart.rs

@@ -159,11 +159,11 @@ impl TypedMultipartError {
     /// it describes a client-supplied field problem). The full `Display`
     /// (including `Other`'s `source`) stays available for server-side
     /// logging via the `std::error::Error` impl.
-    fn response_message(&self) -> String {
+    fn response_message(&self) -> Cow<'_, str> {
         if matches!(self, Self::Other { .. }) {
-            "internal error while processing multipart request".to_owned()
+            Cow::Borrowed("internal error while processing multipart request")
         } else {
-            self.to_string()
+            Cow::Owned(self.to_string())
         }
     }
 }
@@ -221,7 +221,9 @@ impl IntoResponse for TypedMultipartError {
         // fallback keeps this request-time error path panic-free (matching
         // `Validated<T>`'s 422 envelope) by emitting a minimal valid envelope
         // instead of unwinding inside a handler.
-        .unwrap_or_else(|_| br#"{"errors":[{"message":"serialization error","path":""}]}"#.to_vec());
+        .unwrap_or_else(|_| {
+            br#"{"errors":[{"message":"serialization error","path":""}]}"#.to_vec()
+        });
         (
             status,
             [(
@@ -492,6 +494,12 @@ fn str_to_bool(s: &str) -> Option<bool> {
 /// an explicit `#[form_data(limit = "...")]`.
 const DEFAULT_STRING_FIELD_LIMIT_BYTES: usize = 1024 * 1024; // 1 MiB
 
+/// Default streaming cap for an **unannotated** `NamedTempFile` multipart field.
+///
+/// Explicit `#[form_data(limit = "unlimited")]` continues to opt out by passing
+/// `usize::MAX` through the derive-generated parser.
+const DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES: usize = 1024 * 1024; // 1 MiB
+
 impl<S: Send + Sync> TryFromFieldWithState<S> for String {
     async fn try_from_field_with_state(
         field: Field<'_>,
@@ -626,18 +634,17 @@ impl<S: Send + Sync> TryFromFieldWithState<S> for tempfile::NamedTempFile {
         })?;
         let mut file = tokio::fs::File::from_std(std_file);
 
+        let limit_bytes = limit_bytes.unwrap_or(DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES);
         let mut total = 0usize;
         while let Some(chunk) = field.chunk().await? {
             // `saturating_add` (matching `read_field_data`) prevents a
             // pathological chunk size from wrapping `total` and slipping
             // past the limit check below.
             total = total.saturating_add(chunk.len());
-            if let Some(limit) = limit_bytes
-                && total > limit
-            {
+            if total > limit_bytes {
                 return Err(TypedMultipartError::FieldTooLarge {
                     field_name: field.name().unwrap_or_default().to_string(),
-                    limit_bytes: limit,
+                    limit_bytes,
                 });
             }
             tokio::io::AsyncWriteExt::write_all(&mut file, &chunk)

crates/vespera/src/validated.rs

@@ -94,6 +94,16 @@ where
     }
 }
 
+impl<U> ValidatePayload for crate::multipart::TypedMultipart<U>
+where
+    U: Validate<Context = ()>,
+{
+    type Inner = U;
+    fn payload(&self) -> &U {
+        &self.0
+    }
+}
+
 impl<S, T> FromRequest<S> for Validated<T>
 where
     S: Send + Sync,

crates/vespera/tests/multipart_wire.rs

@@ -20,7 +20,7 @@ use ::tokio::runtime::Builder;
 use ::vespera::axum::Json;
 use ::vespera::multipart::{FieldData, TypedMultipart};
 use ::vespera::tempfile::NamedTempFile;
-use ::vespera::{Multipart, Schema};
+use ::vespera::{Multipart, Schema, Validated};
 use ::vespera_inprocess::{dispatch_from_bytes, register_app};
 
 #[derive(Multipart, Schema)]
@@ -34,6 +34,20 @@ struct UploadReq {
     file: FieldData<NamedTempFile>,
 }
 
+#[derive(Multipart, Schema)]
+#[allow(dead_code)]
+struct CappedUploadReq {
+    name: String,
+    file: FieldData<NamedTempFile>,
+}
+
+#[derive(Multipart, Schema, garde::Validate)]
+#[allow(dead_code)]
+struct ValidatedMultipartReq {
+    #[garde(length(min = 3))]
+    name: String,
+}
+
 #[derive(Serialize, Schema)]
 struct UploadResult {
     name: String,
@@ -59,6 +73,29 @@ async fn upload_handler(TypedMultipart(mut req): TypedMultipart<UploadReq>) -> J
     })
 }
 
+async fn capped_upload_handler(
+    TypedMultipart(mut req): TypedMultipart<CappedUploadReq>,
+) -> Json<UploadResult> {
+    let mut buf = Vec::new();
+    let f = req.file.contents.as_file_mut();
+    f.seek(SeekFrom::Start(0)).expect("rewind temp file");
+    f.read_to_end(&mut buf).expect("read temp file");
+    Json(UploadResult {
+        name: req.name,
+        file_size: u64::try_from(buf.len()).expect("file size fits in u64"),
+        file_first_byte: *buf.first().unwrap_or(&0),
+        file_last_byte: *buf.last().unwrap_or(&0),
+    })
+}
+
+async fn validated_multipart_handler(
+    Validated(TypedMultipart(req)): Validated<TypedMultipart<ValidatedMultipartReq>>,
+) -> Json<TextResult> {
+    Json(TextResult {
+        text_len: u64::try_from(req.name.len()).unwrap_or(u64::MAX),
+    })
+}
+
 /// Unannotated `String` field — inherits the default 1 MiB cap.
 #[derive(Multipart, Schema)]
 #[allow(dead_code)]
@@ -96,6 +133,8 @@ async fn text_unlimited_handler(
 fn multipart_router() -> Router {
     Router::new()
         .route("/upload", post(upload_handler))
+        .route("/capped-upload", post(capped_upload_handler))
+        .route("/validated-multipart", post(validated_multipart_handler))
         .route("/text", post(text_handler))
         .route("/text-unlimited", post(text_unlimited_handler))
         // Disable the 2 MiB default so the 256 KiB test below isn't
@@ -116,6 +155,16 @@ fn encode_multipart_wire(
     name: &str,
     file_name: &str,
     file_bytes: &[u8],
+) -> Vec<u8> {
+    encode_multipart_upload_wire("/upload", boundary, name, file_name, file_bytes)
+}
+
+fn encode_multipart_upload_wire(
+    path: &str,
+    boundary: &str,
+    name: &str,
+    file_name: &str,
+    file_bytes: &[u8],
 ) -> Vec<u8> {
     let mut body = Vec::new();
     body.extend_from_slice(format!("--{boundary}\r\n").as_bytes());
@@ -139,7 +188,7 @@ fn encode_multipart_wire(
     let header_json = ::serde_json::json!({
         "v": 1,
         "method": "POST",
-        "path": "/upload",
+        "path": path,
         "headers": headers,
     });
     let header_bytes = ::serde_json::to_vec(&header_json).expect("header serialise");
@@ -341,3 +390,53 @@ fn string_field_unlimited_optout_allows_large() {
     let json: Value = ::serde_json::from_slice(&body).expect("response is JSON");
     assert_eq!(json["text_len"].as_u64(), Some(1024 * 1024 + 1));
 }
+
+#[test]
+fn named_temp_file_over_default_cap_rejected_413() {
+    install_router_once();
+    let runtime = Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("tokio runtime");
+
+    let payload = vec![b'z'; 1024 * 1024 + 1];
+    let wire = encode_multipart_upload_wire(
+        "/capped-upload",
+        "----TempFileCapBoundary",
+        "bob",
+        "too-large.bin",
+        &payload,
+    );
+    let resp = dispatch_from_bytes(wire, &runtime);
+    let (header, _body) = decode_wire(&resp);
+    assert_eq!(
+        header["status"].as_u64(),
+        Some(413),
+        "oversized unannotated tempfile field must be rejected with 413, got header={header:#}"
+    );
+}
+
+#[test]
+fn validated_typed_multipart_rejects_garde_failure_422() {
+    install_router_once();
+    let runtime = Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("tokio runtime");
+
+    let wire = encode_multipart_text(
+        "----ValidatedMultipartBoundary",
+        "/validated-multipart",
+        "name",
+        b"xy",
+    );
+    let resp = dispatch_from_bytes(wire, &runtime);
+    let (header, body) = decode_wire(&resp);
+    assert_eq!(
+        header["status"].as_u64(),
+        Some(422),
+        "garde failure must be rejected with 422, got header={header:#}"
+    );
+    let json: Value = ::serde_json::from_slice(&body).expect("response is JSON");
+    assert_eq!(json["errors"][0]["path"], "name");
+}

crates/vespera_core/src/openapi.rs

@@ -286,16 +286,15 @@ impl OpenApi {
             self.external_docs = other.external_docs;
         }
 
-        // Merge tags, de-duplicating by name in a single pass with first-wins
-        // semantics (existing tags and already-appended incoming tags both
-        // win; incoming insertion order preserved).  Tag lists are tiny, so a
-        // linear membership scan over `self_tags` beats a `HashSet` here: it
-        // allocates nothing and clones nothing — the kept tag is *moved* in,
-        // and a duplicate is detected by borrow and skipped.
+        // Merge tags, de-duplicating by name with first-wins semantics while
+        // preserving deterministic output order (existing tags first, then
+        // incoming tags in their original order).
         if let Some(other_tags) = other.tags {
             let self_tags = self.tags.get_or_insert_with(Vec::new);
+            let mut seen: std::collections::HashSet<String> =
+                self_tags.iter().map(|tag| tag.name.clone()).collect();
             for tag in other_tags {
-                if !self_tags.iter().any(|existing| existing.name == tag.name) {
+                if seen.insert(tag.name.clone()) {
                     self_tags.push(tag);
                 }
             }

crates/vespera_core/src/route.rs

@@ -238,19 +238,30 @@ pub struct PathItem {
 }
 
 impl PathItem {
-    /// Set an operation for a specific HTTP method
-    pub fn set_operation(&mut self, method: HttpMethod, operation: Operation) {
+    /// Try to set an operation for a specific HTTP method.
+    ///
+    /// Returns the operation that was already present, if this call replaced one.
+    pub fn try_set_operation(
+        &mut self,
+        method: HttpMethod,
+        operation: Operation,
+    ) -> Option<Operation> {
         match method {
-            HttpMethod::Get => self.get = Some(operation),
-            HttpMethod::Post => self.post = Some(operation),
-            HttpMethod::Put => self.put = Some(operation),
-            HttpMethod::Patch => self.patch = Some(operation),
-            HttpMethod::Delete => self.delete = Some(operation),
-            HttpMethod::Head => self.head = Some(operation),
-            HttpMethod::Options => self.options = Some(operation),
-            HttpMethod::Trace => self.trace = Some(operation),
+            HttpMethod::Get => self.get.replace(operation),
+            HttpMethod::Post => self.post.replace(operation),
+            HttpMethod::Put => self.put.replace(operation),
+            HttpMethod::Patch => self.patch.replace(operation),
+            HttpMethod::Delete => self.delete.replace(operation),
+            HttpMethod::Head => self.head.replace(operation),
+            HttpMethod::Options => self.options.replace(operation),
+            HttpMethod::Trace => self.trace.replace(operation),
         }
     }
+
+    /// Set an operation for a specific HTTP method, discarding any replaced operation.
+    pub fn set_operation(&mut self, method: HttpMethod, operation: Operation) {
+        let _ = self.try_set_operation(method, operation);
+    }
 }
 
 #[cfg(test)]