Returning errors with Multipart causes issues for large file uploads.

[Fatorin]

Summary

I want to use Axum to accomplish the task of uploading large files.

When handling the upload, I will first check the X-API-KEY in the header to ensure it is correct. Then, I will check if the file format is correct. If there is an issue with the header or the file format, I will return a BadRequest in advance.

For small files, the error message received by the front end is normal. However, for large files (3MB), a net::ERR_CONNECTION_ABORTED error occurs.

I have already adjusted the DefaultBodyLimit and RequestBodyLimitLayer.

Here is my code
Route

let routes_apis = Router::new()
.route("/upload_map", post(upload_map))
.layer(DefaultBodyLimit::disable())
.layer(RequestBodyLimitLayer::new(128 * 1024 * 1024))
.with_state(state.clone());

Handle

pub async fn upload_map(state: State<Arc<AppState>>, headers: HeaderMap, mut multipart: Multipart) -> impl IntoResponse {
    let map_path = match state.config.get_string("MAP_PATH") {
        Ok(code) => code,
        Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({"error": "Server didn't set map path"})))
    };

    let set_valid_code = match state.config.get_string("MAP_VALID_CODE") {
        Ok(code) => code,
        Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({"error": "Server didn't set map valid code"})))
    };

    let mut valid_code = String::new();
    if let Some(header_value) = headers.get("X-API-KEY") {
        valid_code = header_value.to_str().unwrap_or("").to_string();
        if set_valid_code != valid_code {
            return (StatusCode::BAD_REQUEST, Json(json!({"error": "Valid code is wrong"})));
        }
    } else {
        return (StatusCode::BAD_REQUEST, Json(json!({"error": "Valid code not found"})));
    }

    while let Some(mut field) = multipart.next_field().await.unwrap() {
        let file_name = field.file_name().unwrap().to_string();
        let exist_result = file::check_exist(&map_path, &file_name);
        if !exist_result.1 {
            return (StatusCode::BAD_REQUEST, Json(json!({"error": "Has same name map"})));
        }

        let file_path = Path::new(&map_path).join(&file_name);

        let mut buffer = [0u8; 8];
        if let Some(chunk) = field.chunk().await.unwrap() {
            buffer.copy_from_slice(&chunk[..8]);
        }

        if &buffer[0..8] != b"\x89PNG\r\n\x1a\n" {
            return (StatusCode::BAD_REQUEST, Json(json!({"error": "Invalid file format"})));
        }

        let mut file = File::create(&file_path).await.unwrap();
        file.write_all(&buffer).await.unwrap();

        while let Some(chunk) = field.chunk().await.unwrap() {
            file.write_all(&chunk).await.unwrap();
        }
    }

    return (StatusCode::OK, Json(json!({"ok": "Upload successful"})));
}

axum version

0.75

[mladedav]

Where do you observe the net::ERR_CONNECTION_ABORTED? Do you mean that the server sends RST to the client? Do you not get the HTTP status code back?

I'm not sure but it might be because you're sending an error while the body is still being transmitted. It should definitely not discard the error though.

[Fatorin]

You are correct, responding with an error during the transmission phase can cause issues.
I need to implement a proper chunked upload feature and merge the chunks afterward. Thank you for your response.

[mladedav]

So your http client received these disconnect errors? In that case it is still an issue (probably withy hyper or the client though) because I believe it should be valid to send a response before the whole body is read. Especially in a case like yours where it saves pointless transmission of large payload.

[Fatorin]

I tested using Postman and the Chrome browser. Postman has an 80% chance of correctly receiving the error message, but Chrome always shows the net::ERR_CONNECTION_ABORTED exception and does not receive the error message.