• Português

      • Middleware de Timeout

      Oferece suporte de middleware para tratamento de timeout.

      Casos de Uso

      Em serviços web, certas requisições podem demorar muito para serem processadas devido a várias razões (como consultas lentas ao banco de dados, respostas atrasadas de serviços externos, etc.). Para evitar que essas requisições de longa duração consumam recursos do servidor e afetem o processamento de outras requisições, um middleware de timeout pode ser usado para definir um limite máximo de tempo de processamento para as requisições. Se esse limite de tempo for excedido, a requisição será automaticamente encerrada e um erro de timeout será retornado.

      Código de Exemplo

      main.rs
      Cargo.toml
      use std::time::Duration;

use salvo::prelude::*;

#[handler]
async fn fast() -> &'static str {
    "hello"
}
#[handler]
async fn slow() -> &'static str {
    tokio::time::sleep(Duration::from_secs(6)).await;
    "hello"
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();

    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;

    let router = Router::new()
        .hoop(Timeout::new(Duration::from_secs(5)))
        .push(Router::with_path("slow").get(slow))
        .push(Router::with_path("fast").get(fast));

    Server::new(acceptor).serve(router).await;
}

      No exemplo acima, criamos duas funções de manipulação: uma fast de resposta rápida e uma slow que atrasa 6 segundos antes de responder. Um limite de timeout de 5 segundos é definido para todas as requisições usando Timeout::new(Duration::from_secs(5)). Ao acessar o caminho /slow, a requisição atingirá o timeout porque o tempo de processamento excede o limite de 5 segundos. Em contraste, ao acessar o caminho /fast, a requisição será processada normalmente e retornará um resultado.