#WebTransport

WebTransport ist ein auf HTTP/3 basierendes Netzwerkübertragungsprotokoll, das bidirektionale Kommunikation zwischen Client und Server ermöglicht und gleichzeitig niedrige Latenz, hohen Durchsatz und Sicherheit bietet.

#Anwendungsszenarien

WebTransport eignet sich besonders für folgende Szenarien:

• Echtzeitanwendungen: Online-Spiele, Echtzeit-Kollaborationstools, Videokonferenzen und andere Anwendungen, die niedrige Latenz erfordern
• Große Dateiübertragungen: Unterstützt hochdurchsatzfähige Datenübertragungen, ideal für Medienstreams und große Uploads/Downloads
• Multiplex-Kommunikation: Ermöglicht gleichzeitig mehrere bidirektionale und unidirektionale Datenströme
• Datagramm-Kommunikation: Unterstützt ungeordnete und unzuverlässige Datagramm-Kommunikation, perfekt für Szenarien mit extremen Echtzeitanforderungen

Im Vergleich zu WebSocket bietet WebTransport niedrigere Latenz und flexiblere Kommunikationsmodi, insbesondere in instabilen Netzwerkumgebungen.

#Salvo-Implementierung

Das Salvo-Framework bietet native Unterstützung für WebTransport, sodass Entwickler leicht WebTransport-basierte Anwendungen erstellen können. Hauptmerkmale umfassen:

• Unterstützung für WebTransport-Sitzungen
• Bidirektionale Ströme (Bidirectional Streams)
• Unidirektionale Ströme (Unidirectional Streams)
• Datagramm-Übertragung
• Server kann Kommunikationsströme initiieren

#Einfaches Beispiel

Hier ein vereinfachtes Beispiel für einen WebTransport-Server mit Salvo:

#[handler]
async fn connect(req: &mut Request) -> Result<(), salvo::Error> {
    let session = req.web_transport_mut().await.unwrap();
    
    // Datagramme verarbeiten
    if let Ok(Some((_, datagram))) = session.accept_datagram().await {
        // Empfangene Datagramme verarbeiten
        let mut resp = BytesMut::from(&b"Response: "[..]);
        resp.put(datagram);
        session.send_datagram(resp.freeze())?;
    }
    
    // Bidirektionale Ströme verarbeiten
    if let Ok(Some(webtransport::server::AcceptedBi::BidiStream(_, stream))) = session.accept_bi().await {
        let (send, recv) = salvo::proto::quic::BidiStream::split(stream);
        // Bidirektionale Datenströme verarbeiten
    }
    
    Ok(())
}

#Konfiguration und Start

Zum Starten einer WebTransport-fähigen Salvo-Anwendung sind TLS-Zertifikate und ein QUIC-Listener erforderlich:

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

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

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

// Listener einrichten
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;

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

#Vollständiges Beispiel

Für detaillierte Informationen zur WebTransport-Nutzung in Salvo siehe das vollständige Beispiel auf GitHub: https://github.com/salvo-rs/salvo/blob/main/examples/webtransport

Das Beispiel enthält vollständige Implementierungen für Server und Client und zeigt verschiedene WebTransport-Kommunikationsarten.