How to set timeouts?

[frederikhors]

I'm coming from Golang where I can simply use http.Server struct for timeout options like:

func start() {
  httpServer := &http.Server{
    ReadTimeout:  "30s",
    WriteTimeout: "1h",
    //...
  }

  err = httpServer.ListenAndServe()
}

I'm using axum { version = "0.5.16", features = ["json"] } right now and I would like to set these timeouts but I cannot find out how.

Can you help me?

I know axum is using hyper, can you help me understand how to do this?

I'm using the below code:

axum::Server::bind(&addr)
  .serve(app.into_make_service())
  .with_graceful_shutdown(shutdown_signal())
  .await
  .unwrap();

[davidpdrsn]

You can use https://docs.rs/tower-http/latest/tower_http/timeout/index.html

[davidpdrsn]

It's an overall timeout around the whole request.

If you want more low level control I think you have to make your own http_body::Body.

[rhzs]

Hi @davidpdrsn, can you give us working example with Axum? sorry noob here. I tried mine but didnot work.

    let app = Router::with_state(core)
        .route("/users/:id", get(user::users_show))
        .layer(
            ServiceBuilder::new()
                .layer(HandleErrorLayer::new(|_: BoxError| async {
                    error!("some error");
                    StatusCode::REQUEST_TIMEOUT
                }))
                .layer(TimeoutLayer::new(Duration::from_nanos(0)))  // Set it to `0` but still did not get REQUEST TIMEOUT status code
        )

[davidpdrsn]

What does user::users_show do, specifically does it await anything?

Async timeouts work by

• Creating a sleep future for the supplied timeout duration
• In a loop
  • Polling your inner future i.e. user::users_show. If so then we're done
  • If its not done poll the sleep and see if thats done. If so then we hit the timeout

So if user::users_show never awaits anything then it'll complete immediately and thus we don't poll the sleep/timeout.

[rhzs]

Thanks for your reply @davidpdrsn.

What does user::users_show do, specifically does it await anything?

I did simulate the wait by giving a sleep. sleep(Duration::from_secs(3)).await;.

I managed to make it work with the following:

let middleware = ServiceBuilder::new()
    .layer(HandleErrorLayer::new(handle_timeout_error))
    .timeout(Duration::from_secs(10));

let app = Router::with_state(core)
    .route("/users/:id", get(user::users_show))
    .layer(middleware.into_inner());

handle_timeout_error part:

use axum::{
    http::{Method, StatusCode, Uri},
    BoxError,
};

use tower;

fn handle_timeout_error(_method: Method, _uri: Uri, err: BoxError) -> (StatusCode, String) {
    if err.is::<tower::timeout::error::Elapsed>() {
        (
            StatusCode::REQUEST_TIMEOUT,
            "Request took too long".to_string(),
        )
    } else {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            format!("Unhandled internal error: {}", err),
        )
    }
}

[wacdev]

see the image above , I try use this code, but get error

the trait `Service<Request<_>>` is not implemented for `HandleError<tower::timeout::Timeout<Route<_>>, fn(Method, Uri, Box<(dyn std::error::Error + Send + Sync + 'static)>) -> (StatusCode, String) {handle}, _>`

[avdb13]

I tried this but for some reason my handler keeps getting called over and over again without hitting a timeout, eventually failing with a connection reset.

Router:

pub async fn timeout(method: Method, uri: Uri, err: BoxError) -> impl IntoResponse {
    if err.is::<Elapsed>() {
        (
            StatusCode::REQUEST_TIMEOUT,
            format!("request timeout: {method} on {uri}"),
        )
    } else {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            format!("internal server error: {method} on {uri}"),
        )
    }
}

    let timeout_layer = ServiceBuilder::new()
        .layer(HandleErrorLayer::new(handlers::timeout))
        .timeout(Duration::from_secs(1));

    Router::new()
        .merge(SpaRouter::new("/tmp", ".tmp"))
        .route("/", get(handlers::get_root))
        ...
        .layer(timeout_layer.into_inner())
        .route_layer(middleware::from_fn(signed_in))
        .layer(session_layer)
        .with_state(app)
        .layer(TraceLayer::new_for_http())
        .layer(DefaultBodyLimit::disable())

I replicated the exact same steps. Duration::from_secs(0) seems to work but anything other than that retries the request before it can manage to hit the timer.

[josecelano]

Same here.

[davidpdrsn]

Are you able to provide a minimal reproduction script?

[josecelano]

Hi @davidpdrsn I have been able to make it work:

https://github.com/josecelano/axum-request-timeout

While I was building the minimum example to share with you.

Anyway, I think I mixed up two different things. What I'm looking for it's a timeout to close the HTTP connection if the client does not transmit the entire set of headers within this time. Like in ActixWeb:

Defines a timeout for reading client request head. If a client does not transmit the entire set headers within this time, the request is terminated with a 408 (Request Timeout) error.

https://docs.rs/actix-web/latest/actix_web/struct.HttpServer.html#method.client_request_timeout

I'm working on this issue: torrust/torrust-index#204

I've been trying with:

    let server = axum::Server::from_tcp(tcp_listener)
        .expect("a new server from the previously created tcp listener.")
        .http1_header_read_timeout(std::time::Duration::from_secs(5))
        .http2_keep_alive_timeout(std::time::Duration::from_secs(5))
        .serve(app.into_make_service_with_connect_info::<SocketAddr>());

But it does not work. Any suggestion? I was about to open a new issue.

[davidpdrsn]

Not sure. Try asking in the hyper repo.

[josecelano]

Just for the record, there is an open issue in the Hyper repo for timeouts while waiting for headers.