WebSocket in Rust: Bibliotheken tokio-tungstenite und tungstenite

WebSocket-Bibliotheken für Rust: tungstenite und tokio-tungstenite

WebSocket ist ein Protokoll, das eine Vollduplex-Kommunikation zwischen Client und Server über eine einzige TCP-Verbindung ermöglicht. Im Rust-Ökosystem sind die beliebtesten Bibliotheken für die Arbeit mit WebSocket tungstenite (synchron) und tokio-tungstenite (asynchron basierend auf Tokio). Beide Bibliotheken bieten eine hochwertige API zum Erstellen von WebSocket-Servern und -Clients, unterstützen Standarderweiterungen und Sicherheit über TLS.

Hauptfunktionen

• tungstenite: synchrone Implementierung von WebSocket (RFC 6455), unterstützt blockierende Operationen, geeignet für einfache Skripte und Einbettung.
• tokio-tungstenite: asynchrone Wrapper um tungstenite, integriert mit der Tokio-Laufzeit, ermöglicht die gleichzeitige Verarbeitung tausender Verbindungen.
• Unterstützung für Frames, Nachrichten, Pings/Pongs, Verbindungsschließung.
• Arbeit mit TLS (über rustls oder native-tls).
• Unterstützung für WebSocket-Erweiterungen (z. B. Komprimierung permessage-deflate).
• Einfache Konfiguration und minimale Abhängigkeiten.

Installation

Fügen Sie die Bibliothek zur Cargo.toml hinzu:

[dependencies]tokio-tungstenite = "0.21"       # asynchrone Variantetungstenite = "0.21"             # synchrone Variantetokio = { version = "1", features = ["full"] }  # für tokio-tungstenite

Beispiel eines asynchronen WebSocket-Servers (tokio-tungstenite)

Erstellen wir einen einfachen Echo-Server, der Textnachrichten empfängt und zurücksendet:

use tokio::net::TcpListener;use tokio_tungstenite::accept_async;use tokio_tungstenite::tungstenite::Message;use futures_util::{SinkExt, StreamExt};

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let listener = TcpListener::bind("127.0.0.1:9001").await?;    println!("WebSocket-Server gestartet auf ws://127.0.0.1:9001");

    while let Ok((stream, peer)) = listener.accept().await {        tokio::spawn(handle_connection(stream, peer));    }    Ok(())}

async fn handle_connection(stream: tokio::net::TcpStream, peer: std::net::SocketAddr) {    let ws_stream = match accept_async(stream).await {        Ok(ws) => ws,        Err(e) => {            eprintln!("Fehler bei Verbindung {}: {}", peer, e);            return;        }    };

    let (mut write, mut read) = ws_stream.split();    println!("Neue Verbindung: {}", peer);

    while let Some(msg) = read.next().await {        match msg {            Ok(Message::Text(text)) => {                println!("Erhalten von {}: {}", peer, text);                if let Err(e) = write.send(Message::Text(text.into())).await {                    eprintln!("Fehler beim Senden: {}", e);                    break;                }            }            Ok(Message::Close(_)) => {                println!("Client {} getrennt", peer);                break;            }            Err(e) => {                eprintln!("Fehler: {}", e);                break;            }            _ => {} // Ignoriere binäre und Kontrollnachrichten        }    }}

Beispiel eines synchronen WebSocket-Clients (tungstenite)

Ein einfacher Client, der eine Verbindung zum Server herstellt und eine Nachricht sendet:

use tungstenite::{connect, Message};use url::Url;

fn main() -> Result<(), Box<dyn std::error::Error>> {    let url = Url::parse("ws://echo.websocket.org")?;    let (mut socket, response) = connect(url)?;

    println!("Mit Server verbunden");    println!("HTTP-Status: {}", response.status());

    socket.send(Message::Text("Hallo, WebSocket!".into()))?;    println!("Nachricht gesendet");

    let msg = socket.read()?;    if let Message::T