• Italiano

      • Compatibilità Middleware Tower

      Salvo fornisce supporto di compatibilità per l'ecosistema Tower attraverso la funzionalità tower-compat. Per le API specifiche, si prega di consultare la documentazione.

      Concetti Fondamentali di Tower

      Tower è una libreria di astrazione dei servizi basata principalmente su due tratti fondamentali:

      Tratto Service

      pub trait Service<Request> {
    type Response;
    type Error;
    type Future: Future<Output = Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;
    fn call(&mut self, req: Request) -> Self::Future;
}

      Il tratto Service è responsabile della gestione delle richieste e della restituzione delle risposte, simile agli handler di Salvo.

      Tratto Layer

      pub trait Layer<S> {
    type Service;
    fn layer(&self, inner: S) -> Self::Service;
}

      Il tratto Layer viene utilizzato per avvolgere i servizi e aggiungere funzionalità aggiuntive, simile al middleware di Salvo.

      Supporto alla Compatibilità di Salvo

      Salvo fornisce due tratti chiave per ottenere la compatibilità con l'ecosistema Tower:

      • TowerLayerCompat: Converte il Layer di Tower nell'Handler di Salvo, consentendone l'uso come Hoop (middleware).
      • TowerServiceCompat: Converte il Service di Tower nell'Handler di Salvo.

      Esempio di utilizzo:

      // Utilizza il RateLimitLayer di Tower e lo converte in un formato compatibile con Salvo tramite il metodo compat()
let limit = RateLimitLayer::new(5, Duration::from_secs(30)).compat();
let router = Router::new().hoop(limit).get(hello);

      Codice di Esempio

      main.rs
      Cargo.toml
      use salvo::prelude::*;
use tokio::time::Duration;
use tower::limit::RateLimitLayer;

#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

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

    let limit = RateLimitLayer::new(5, Duration::from_secs(30)).compat();
    let acceptor = TcpListener::new("0.0.0.0:8698").bind().await;
    let router = Router::new().hoop(limit).get(hello);
    Server::new(acceptor).serve(router).await;
}