#WebTransport

WebTransport è un protocollo di trasmissione basato su HTTP/3 che fornisce capacità di comunicazione bidirezionale tra client e server, combinando bassa latenza, alta velocità di trasferimento e sicurezza.

#Casi d'uso

WebTransport è particolarmente adatto per:

• Applicazioni in tempo reale: giochi online, strumenti di collaborazione in tempo reale, videoconferenze e altre applicazioni che richiedono comunicazioni a bassa latenza
• Trasferimento di file di grandi dimensioni: supporta trasmissioni dati ad alta velocità, ideale per streaming multimediali e upload/download di file voluminosi
• Comunicazione multiplex: permette di stabilire simultaneamente multipli flussi di dati bidirezionali e unidirezionali
• Comunicazione tramite datagrammi: supporta la trasmissione di datagrammi senza garanzia di ordinamento e affidabilità, perfetta per scenari con requisiti estremi di real-time

Rispetto a WebSocket, WebTransport offre latenza inferiore e modalità di comunicazione più flessibili, con prestazioni migliori soprattutto in condizioni di rete instabili.

#Implementazione in Salvo

Il framework Salvo fornisce supporto nativo per WebTransport, consentendo agli sviluppatori di costruire facilmente applicazioni basate su questa tecnologia. Le caratteristiche principali includono:

• Supporto per l'instaurazione di sessioni WebTransport
• Supporto per flussi bidirezionali (Bidirectional Streams)
• Supporto per flussi unidirezionali (Unidirectional Streams)
• Supporto per la trasmissione di datagrammi
• Possibilità per il server di avviare flussi di comunicazione

#Esempio semplice

Ecco un esempio semplificato di server WebTransport implementato con Salvo:

#[handler]
async fn connect(req: &mut Request) -> Result<(), salvo::Error> {
    let session = req.web_transport_mut().await.unwrap();
    
    // Gestione datagrammi
    if let Ok(Some((_, datagram))) = session.accept_datagram().await {
        // Elabora il datagramma ricevuto
        let mut resp = BytesMut::from(&b"Response: "[..]);
        resp.put(datagram);
        session.send_datagram(resp.freeze())?;
    }
    
    // Gestione flussi bidirezionali
    if let Ok(Some(webtransport::server::AcceptedBi::BidiStream(_, stream))) = session.accept_bi().await {
        let (send, recv) = salvo::proto::quic::BidiStream::split(stream);
        // Elabora i dati del flusso bidirezionale
    }
    
    Ok(())
}

#Configurazione e avvio

Per avviare un'applicazione Salvo con supporto WebTransport è necessario configurare certificati TLS e listener QUIC:

let cert = include_bytes!("../certs/cert.pem").to_vec();
let key = include_bytes!("../certs/key.pem").to_vec();

// Configurazione routing
let router = Router::new().push(Router::with_path("counter").goal(connect));

// Configurazione TLS
let config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));

// Configurazione listener
let listener = TcpListener::new(("0.0.0.0", 5800)).rustls(config.clone());
let acceptor = QuinnListener::new(config, ("0.0.0.0", 5800))
    .join(listener)
    .bind()
    .await;

// Avvio server
Server::new(acceptor).serve(router).await;

#Esempio completo

Per approfondire l'utilizzo di WebTransport in Salvo, consulta l'esempio completo su GitHub: https://github.com/salvo-rs/salvo/blob/main/examples/webtransport

L'esempio include implementazioni complete sia lato server che client, dimostrando come gestire diversi tipi di comunicazione WebTransport.