How to get "413" HTTP status code with RequestBodyLimitLayer?

[frederikhors]

Using the below code I expect to get a "413" HTTP status code in return if I upload files > 10MB but I get no HTTP status code instead. Why?

use axum::{
    body::boxed,
    extract::BodyStream,
    headers::ContentLength,
    http::{header, HeaderValue, Method, StatusCode},
    response::Response,
    routing::{on, MethodFilter},
    Router, TypedHeader,
};
use futures::TryStreamExt;
use std::{io, net::SocketAddr, path::Path, pin::Pin};
use tokio::{fs::File, io::AsyncRead};
use tokio_util::io::StreamReader;
use tower_http::{cors::CorsLayer, limit::RequestBodyLimitLayer};

#[tokio::main]
async fn main() {
    let router = Router::new()
        .route("/files/upload", on(MethodFilter::POST, upload))
        .layer(RequestBodyLimitLayer::new(5 * 1024 * 1024))
        .layer(
            CorsLayer::new()
                .allow_origin("http://localhost:4000".parse::<HeaderValue>().unwrap())
                .allow_methods([Method::GET, Method::POST])
                .allow_headers([header::CONTENT_TYPE])
                .allow_credentials(true),
        );

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    axum::Server::bind(&addr)
        .serve(router.into_make_service())
        .await
        .unwrap();
}

pub async fn upload(
    TypedHeader(content_length): TypedHeader<ContentLength>,
    stream: BodyStream,
) -> Result<Response, StatusCode> {
    dbg!(content_length.0);

    let stream = stream.map_err(|err| io::Error::new(io::ErrorKind::Other, err));

    create_file("filename", Box::pin(StreamReader::new(stream)))
        .await
        .unwrap();

    Ok(Response::builder()
        .status(StatusCode::CREATED)
        .body(boxed("OK".to_string()))
        .unwrap())
}

async fn create_file(
    filename: &str,
    mut stream: Pin<Box<(dyn AsyncRead + Send + Sync)>>,
) -> Result<(), ()> {
    let path = Path::new(".").join(filename);

    let mut file = File::create(&path).await.unwrap();

    tokio::io::copy(&mut stream, &mut file).await.unwrap();

    Ok(())
}

[dependencies]
axum = { version = "0.5.17", features = ["headers"] }
futures = "0.3.25"
tokio = { version = "1.21.2", features = ["full"] }
tower-http = { version = "0.3.4", features = ["limit", "cors"] }
tokio-util = { version = "0.7.4", features = ["io"] }

[davidpdrsn]

If the request has a content-type then that should work.

[frederikhors]

The (javascript) client is sending: Content-Type: application/x-zip-compressed or whatever the file type is.

Maybe the call is "truncated" because of the bigger size and the response (with the status code) is not sent?

[frederikhors]

[davidpdrsn]

Oh sorry my bad I meant content-length.

If the request has a known length it'll be rejected right away if it's too big, otherwise you have to actually consume the data which will then get limited.

That is explained here https://docs.rs/tower-http/0.3.5/tower_http/limit/index.html#examples

[frederikhors]

Yeah . I know that.

I tried with Postman and the 413 is received. I think the javascript client is unable to retrieve the HTTP Status code if the connection is aborted.

Could this be the problem?

[davidpdrsn]

RequestBodyLimitLayer does not close the connection without sending a response.