• Français

      • Middleware de Timeout

      Fournit une prise en charge de middleware pour la gestion des délais d'attente.

      Cas d'utilisation

      Dans les services web, certaines requêtes peuvent prendre trop de temps à traiter pour diverses raisons (telles que des requêtes de base de données lentes, des réponses retardées de services externes, etc.). Pour éviter que ces requêtes de longue durée ne consomment les ressources du serveur et n'affectent le traitement des autres requêtes, un middleware de timeout peut être utilisé pour définir une limite de temps de traitement maximale pour les requêtes. Si cette limite de temps est dépassée, la requête sera automatiquement interrompue et une erreur de timeout sera renvoyée.

      Exemple de code

      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;
}

      Dans l'exemple ci-dessus, nous avons créé deux fonctions de gestion : une fonction fast à réponse rapide et une fonction slow qui retarde de 6 secondes avant de répondre. Une limite de timeout de 5 secondes est définie pour toutes les requêtes en utilisant Timeout::new(Duration::from_secs(5)). Lors de l'accès au chemin /slow, la requête expirera car le temps de traitement dépasse la limite de 5 secondes. En revanche, lors de l'accès au chemin /fast, la requête sera traitée normalement et renverra un résultat.