#WebTransport

O WebTransport é um protocolo de transporte de rede baseado em HTTP/3, que fornece capacidades de comunicação bidirecional entre clientes e servidores, garantindo baixa latência, alta taxa de transferência e segurança.

#Casos de Uso

O WebTransport é particularmente adequado para os seguintes cenários:

• Aplicações em Tempo Real: Jogos online, ferramentas de colaboração em tempo real, videoconferências e outras aplicações que exigem comunicação de baixa latência.
• Transferências de Arquivos Grandes: Suporta transmissão de dados de alta taxa de transferência, ideal para streaming de mídia e upload/download de arquivos grandes.
• Comunicação Multiplexada: Permite estabelecer simultaneamente múltiplos fluxos de dados bidirecionais e unidirecionais.
• Comunicação por Datagrama: Suporta comunicação por datagrama sem garantia de ordem ou confiabilidade, adequada para cenários com requisitos de tempo real extremamente altos.

Comparado ao WebSocket, o WebTransport oferece menor latência e padrões de comunicação mais flexíveis, especialmente com melhor desempenho em ambientes de rede instáveis.

#Implementação no Salvo

O framework Salvo fornece suporte integrado para WebTransport, permitindo que os desenvolvedores construam facilmente aplicações baseadas em WebTransport. As principais funcionalidades incluem:

• Suporte para estabelecer sessões WebTransport
• Suporte para comunicação por fluxo bidirecional
• Suporte para comunicação por fluxo unidirecional
• Suporte para transmissão de datagramas
• Fluxos de comunicação iniciados pelo servidor

#Exemplo Simples

Abaixo está um exemplo simplificado de implementação de um servidor WebTransport usando Salvo:

#[handler]
async fn connect(req: &mut Request) -> Result<(), salvo::Error> {
    let session = req.web_transport_mut().await.unwrap();
    
    // Manipular datagramas
    if let Ok(Some((_, datagram))) = session.accept_datagram().await {
        // Processar datagrama recebido
        let mut resp = BytesMut::from(&b"Response: "[..]);
        resp.put(datagram);
        session.send_datagram(resp.freeze())?;
    }
    
    // Manipular fluxos bidirecionais
    if let Ok(Some(webtransport::server::AcceptedBi::BidiStream(_, stream))) = session.accept_bi().await {
        let (send, recv) = salvo::proto::quic::BidiStream::split(stream);
        // Processar dados do fluxo bidirecional
    }
    
    Ok(())
}

#Configuração e Inicialização

Iniciar uma aplicação Salvo com suporte a WebTransport requer a configuração de certificados TLS e um listener QUIC:

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

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

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

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

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

#Exemplo Completo

Para saber mais sobre como usar WebTransport no Salvo, consulte o exemplo completo no GitHub: https://github.com/salvo-rs/salvo/blob/main/examples/webtransport

Este exemplo inclui implementações completas tanto para servidor quanto para cliente, demonstrando como lidar com vários tipos de comunicação WebTransport.