• Italiano

      • Limitazione della Concorrenza

      Il middleware Limitazione della Concorrenza consente di controllare il numero di richieste simultanee. Per i dettagli specifici delle API, consultare la documentazione.

      Scenari di Applicazione

      Il limitatore di concorrenza risulta particolarmente utile nei seguenti scenari:

      • Protezione di Siti Web ad Alto Traffico: Limita il numero di richieste elaborate contemporaneamente durante picchi di traffico per prevenire il sovraccarico del server.
      • Controllo di Operazioni ad Alto Consumo di Risorse: Restringe la concorrenza per operazioni impegnative come caricamenti di file e scritture su database.
      • Limitazione delle Chiamate ad API di Terze Parti: Controlla il numero di richieste simultanee quando si utilizzano servizi esterni con limiti di frequenza.

      Funzioni Principali

      • Prevenire il Sovraccarico del Server: Mantiene la stabilità del server durante i picchi di traffico limitando le richieste simultanee.
      • Migliorare l'Affidabilità del Sistema: Evita il blocco del sistema causato dall'esaurimento delle risorse.
      • Ottimizzare l'Allocazione delle Risorse: Garantisce che i servizi critici dispongano di risorse sufficienti per gestire le richieste.

      Utilizzo

      È sufficiente aggiungere il middleware max_concurrency(n) alla propria rotta, dove n rappresenta il numero massimo di richieste simultanee consentite. Le richieste che superano questo limite riceveranno una risposta 503 Servizio Non Disponibile.

      Codice di Esempio

      main.rs
      Cargo.toml
      use std::fs::create_dir_all;
use std::path::Path;

use salvo::prelude::*;

// Handler for serving the index page with upload forms
#[handler]
async fn index(res: &mut Response) {
    res.render(Text::Html(INDEX_HTML));
}

// Handler for processing file uploads with a simulated delay
#[handler]
async fn upload(req: &mut Request, res: &mut Response) {
    // Extract file from the multipart form data
    let file = req.file("file").await;
    // Simulate a long-running operation (10 seconds)
    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;

    if let Some(file) = file {
        // Generate destination path for the uploaded file
        let dest = format!("temp/{}", file.name().unwrap_or("file"));
        tracing::debug!(dest = %dest, "upload file");

        // Copy file to destination
        if let Err(e) = std::fs::copy(file.path(), Path::new(&dest)) {
            res.status_code(StatusCode::INTERNAL_SERVER_ERROR);
            res.render(Text::Plain(format!("file not found in request: {e}")));
        } else {
            res.render(Text::Plain(format!("File uploaded to {dest}")));
        }
    } else {
        res.status_code(StatusCode::BAD_REQUEST);
        res.render(Text::Plain("file not found in request"));
    }
}

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

    // Create temporary directory for file uploads
    create_dir_all("temp").unwrap();

    // Configure router with two upload endpoints:
    // - /limited: Only allows one concurrent upload (with concurrency limiter)
    // - /unlimit: Allows unlimited concurrent uploads
    let router = Router::new()
        .get(index)
        .push(
            Router::new()
                .hoop(max_concurrency(1)) // Limit concurrent requests to 1
                .path("limited")
                .post(upload),
        )
        .push(Router::with_path("unlimit").post(upload));

    // Bind server to port 8698 and start serving
    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;
    Server::new(acceptor).serve(router).await;
}

// HTML template for the upload forms page
static INDEX_HTML: &str = r#"<!DOCTYPE html>
<html>
    <head>
        <title>Upload file</title>
    </head>
    <body>
        <h1>Upload file</h1>
        <form action="/unlimit" method="post" enctype="multipart/form-data">
            <h3>Unlimit</h3>
            <input type="file" name="file" />
            <input type="submit" value="upload" />
        </form>
        <form action="/limited" method="post" enctype="multipart/form-data">
            <h3>Limited</h3>
            <input type="file" name="file" />
            <input type="submit" value="upload" />
        </form>
    </body>
</html>
"#;