server 函数的请求体

    // One-arg case
    impl<In, Out, H> ExtractRequest<In, Out, H> for &&&&&&&&&&ServerFnEncoder<In, Out>
    where
        In: DeserializeOwned + 'static,
        Out: 'static,
        H: FromRequestParts<FullstackContext>,
    {
        fn extract_axum(
            &self,
            _state: FullstackContext,
            request: Request,
            map: fn(In) -> Out,
        ) -> impl Future<Output = Result<(Out, H), Response>> + 'static {
            async move {
                let (mut parts, body) = request.into_parts();
                let headers = H::from_request_parts(&mut parts, &_state)
                    .await
                    .map_err(|e| e.into_response())?;

                let request = Request::from_parts(parts, body);
                let bytes = Bytes::from_request(request, &()).await.unwrap();
                let as_str = String::from_utf8_lossy(&bytes);

                let bytes = if as_str.is_empty() {
                    "{}".as_bytes()
                } else {
                    &bytes
                };

                let out = serde_json::from_slice::<In>(bytes)
                    .map(map)
                    .map_err(|e| ServerFnError::from(e).into_response())?;

                Ok((out, headers))
            }
        }
    }

                match result {
                    Ok(response) => response,
                    Err(err) => Response::builder()
                        .status(StatusCode::INTERNAL_SERVER_ERROR)
                        .body(Body::new(if cfg!(debug_assertions) {
                            format!("Server function panicked: {}", err)
                        } else {
                            "Internal Server Error".to_string()
                        }))
                        .unwrap(),
                }

bytes = "=1.12.1"
tokio = { version = "=1.54.1", features = ["full"] }
axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
tokio-util = { version = "=0.7.18", features = ["rt"] }
futures-util = "0.3"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
base64 = "=0.22.1"

use std::alloc::{GlobalAlloc, Layout, System};
use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};

use axum::{
  Router,
  body::{Body, Bytes, to_bytes},
  extract::{DefaultBodyLimit, FromRequest, Request, State},
  http::StatusCode,
  middleware::{self, Next},
  response::{IntoResponse, Response},
  routing::post,
};
use base64::Engine as _;
use serde::Deserialize;
use tokio_util::task::LocalPoolHandle;
use tower::{Layer, ServiceExt};

const MIB: usize = 1024 * 1024;

// 只记 1 MiB 以上的分配
struct Counting;
static BIG_N: AtomicUsize = AtomicUsize::new(0);
static BIG_SIZES: [AtomicUsize; 16] = [const { AtomicUsize::new(0) }; 16];

unsafe impl GlobalAlloc for Counting {
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    if layout.size() >= MIB {
      let i = BIG_N.fetch_add(1, Relaxed);
      if i < 16 {
        BIG_SIZES[i].store(layout.size(), Relaxed);
      }
    }
    unsafe { System.alloc(layout) }
  }
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
    unsafe { System.dealloc(ptr, layout) }
  }
}

#[global_allocator]
static GLOBAL: Counting = Counting;

fn big_allocs() -> Vec<usize> {
  let n = BIG_N.swap(0, Relaxed).min(16);
  (0..n).map(|i| BIG_SIZES[i].load(Relaxed)).collect()
}

#[derive(Deserialize)]
struct UploadArgs {
  name: String,
  data_base64: String,
}

// 普通的 axum handler：Bytes 提取器失败时由 axum 回 rejection
async fn plain(body: Bytes) -> String {
  format!("got {} bytes", body.len())
}

// 照 dioxus 0.7.9 的做法：dioxus-server 的 make_handler 用 spawn_pinned 跑，
// 里面是 dioxus-fullstack magic.rs 的 Bytes::from_request(..).await.unwrap() + serde_json::from_slice
async fn server_fn(State(pool): State<LocalPoolHandle>, req: Request) -> Response {
  let result = pool
    .spawn_pinned(move || async move {
      let bytes = Bytes::from_request(req, &()).await.unwrap();
      let args = match serde_json::from_slice::<UploadArgs>(&bytes) {
        Ok(args) => args,
        Err(e) => return (StatusCode::BAD_REQUEST, e.to_string()).into_response(),
      };
      // 本站 upload_image 接着做的事：先按 len * 3 / 4 估算大小（check_upload_size），再 base64 解码。
      // ServerFnError::new 在 dioxus 里是 500
      if args.data_base64.len() * 3 / 4 > 5 * MIB {
        return (StatusCode::INTERNAL_SERVER_ERROR, "文件过大（限制 5 MB）").into_response();
      }
      let data = base64::engine::general_purpose::STANDARD.decode(&args.data_base64).unwrap();
      format!("ok {} {} bytes", args.name, data.len()).into_response()
    })
    .await;
  match result {
    Ok(res) => res,
    // dioxus-server 在 debug 构建里回这句，release 构建里回 "Internal Server Error"
    Err(err) => (StatusCode::INTERNAL_SERVER_ERROR, format!("Server function panicked: {err}")).into_response(),
  }
}

// 本站 2026-10-23 的修法：只给 /api/upload 套 DefaultBodyLimit::max(8 MiB)
async fn upload_body_limit(req: Request, next: Next) -> Response {
  if req.uri().path() != "/api/upload" {
    return next.run(req).await;
  }
  match DefaultBodyLimit::max(8 * MIB).layer(next).oneshot(req).await {
    Ok(res) => res,
    Err(never) => match never {},
  }
}

async fn send(app: &Router, path: &str, image_bytes: usize) {
  let b64 = base64::engine::general_purpose::STANDARD.encode(vec![0u8; image_bytes]);
  let json = format!(r#"{{"name":"a.png","data_base64":"{b64}"}}"#);
  let json_len = json.len();
  // 像 hyper 一样分块交上来：每块 32 KiB
  let chunks: Vec<Bytes> = json.into_bytes().chunks(32 * 1024).map(Bytes::copy_from_slice).collect();
  let stream = futures_util::stream::iter(chunks.into_iter().map(Ok::<_, std::io::Error>));
  let req = Request::post(path).body(Body::from_stream(stream)).unwrap();
  println!("{path:<12} 图片 {image_bytes} B，JSON {json_len} B");

  big_allocs();
  let res = app.clone().oneshot(req).await.unwrap();
  let big = big_allocs();
  let status = res.status().as_u16();
  let text = to_bytes(res.into_body(), MIB).await.unwrap();
  println!("  {status} {}", String::from_utf8_lossy(&text));
  println!("  1 MiB 以上的分配: {big:?}");
}

#[tokio::main]
async fn main() {
  std::panic::set_hook(Box::new(|info| {
    let msg = info.payload().downcast_ref::<String>().cloned().unwrap_or_default();
    println!("  [panic] {msg}");
  }));
  let pool = LocalPoolHandle::new(1);
  let routes = Router::new()
    .route("/plain", post(plain))
    .route("/api/upload", post(server_fn))
    .with_state(pool);

  println!("== 修之前");
  send(&routes, "/plain", 1_600_000).await;
  send(&routes, "/api/upload", 1_500_000).await;
  send(&routes, "/api/upload", 1_600_000).await;

  println!("== 修之后");
  let fixed = routes.layer(middleware::from_fn(upload_body_limit));
  send(&fixed, "/plain", 1_600_000).await;
  send(&fixed, "/api/upload", 5_000_000).await;
  send(&fixed, "/api/upload", 6_000_000).await;
  send(&fixed, "/api/upload", 6_500_000).await;
}

== 修之前
/plain       图片 1600000 B，JSON 2133369 B
  413 Failed to buffer the request body: length limit exceeded
  1 MiB 以上的分配: []
/api/upload  图片 1500000 B，JSON 2000033 B
  200 ok a.png 1500000 bytes
  1 MiB 以上的分配: [2000033, 2000000, 1500000]
/api/upload  图片 1600000 B，JSON 2133369 B
  [panic] called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))
  500 Server function panicked: task 15 panicked with message "called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))"
  1 MiB 以上的分配: []
== 修之后
/plain       图片 1600000 B，JSON 2133369 B
  413 Failed to buffer the request body: length limit exceeded
  1 MiB 以上的分配: []
/api/upload  图片 5000000 B，JSON 6666701 B
  200 ok a.png 5000000 bytes
  1 MiB 以上的分配: [6666701, 6666668, 5000001]
/api/upload  图片 6000000 B，JSON 8000033 B
  500 文件过大（限制 5 MB）
  1 MiB 以上的分配: [8000033, 8000000]
/api/upload  图片 6500000 B，JSON 8666701 B
  [panic] called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))
  500 Server function panicked: task 21 panicked with message "called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))"
  1 MiB 以上的分配: []