Rust की WebSocket लाइब्रेरीज़: tokio-tungstenite और async-tungstenite

Rust की WebSocket लाइब्रेरीज़: tokio-tungstenite और async-tungstenite

WebSocket एक प्रोटोकॉल है जो एक TCP कनेक्शन पर क्लाइंट और सर्वर के बीच द्वि-दिशात्मक संचार प्रदान करता है। Rust पारिस्थितिकी तंत्र में WebSocket के साथ काम करने के लिए दो मुख्य लाइब्रेरीज़ का उपयोग किया जाता है: tokio-tungstenite (Tokio पर आधारित अतुल्यकालिक) और async-tungstenite (अतुल्यकालिक, लेकिन विभिन्न रनटाइम के समर्थन के साथ)। दोनों निम्न-स्तरीय लाइब्रेरी tungstenite पर आधारित हैं, जो स्वयं WebSocket प्रोटोकॉल को लागू करती है।

Rust में WebSocket का उपयोग क्यों करें?

Rust एक सिस्टम भाषा है जो उच्च-लोड वाले नेटवर्क अनुप्रयोगों को बनाने के लिए आदर्श है। Rust की WebSocket लाइब्रेरीज़ निम्नलिखित की अनुमति देती हैं:

• रीयल-टाइम में चैट, गेम, सूचना प्रणाली बनाना
• न्यूनतम मेमोरी खपत के साथ हजारों समवर्ती कनेक्शनों को संभालना
• संकलन स्तर पर Rust की मेमोरी सुरक्षा का उपयोग करना
• अन्य अतुल्यकालिक लाइब्रेरीज़ (जैसे, HTTP सर्वर) के साथ एकीकृत होना

स्थापना और कॉन्फ़िगरेशन

Cargo.toml में निर्भरता जोड़ें:

[dependencies]tokio = { version = "1", features = ["full"] }tokio-tungstenite = "0.21"futures-util = "0.3"

async-tungstenite के लिए:

[dependencies]async-tungstenite = "0.25"async-std = "1.12"

Rust पर WebSocket क्लाइंट बनाना

एक सरल क्लाइंट का उदाहरण जो सर्वर से जुड़ता है और संदेश भेजता है:

use futures_util::{SinkExt, StreamExt};use tokio_tungstenite::{connect_async, tungstenite::Message};

#[tokio::main]async fn main() {    let url = "wss://echo.websocket.org";    let (mut ws_stream, _) = connect_async(url).await.expect("कनेक्शन में त्रुटि");

    println!("सर्वर से जुड़ गया");

    // संदेश भेजें    ws_stream.send(Message::Text("नमस्ते, WebSocket!".into())).await.unwrap();

    // उत्तर प्राप्त करें    if let Some(msg) = ws_stream.next().await {        let msg = msg.unwrap();        if let Message::Text(text) = msg {            println!("प्राप्त: {}", text);        }    }

    ws_stream.close(None).await.unwrap();}

Rust पर WebSocket सर्वर बनाना

सर्वर जो कनेक्शन स्वीकार करता है और इको उत्तर देता है:

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

#[tokio::main]async fn main() {    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();    println!("सर्वर ws://127.0.0.1:8080 पर शुरू हुआ");

    while let Ok((stream, addr)) = listener.accept().await {        tokio::spawn(async move {            println!("नया कनेक्शन: {}", addr);

            let ws_stream = accept_async(stream).await.unwrap();            let (mut sender, mut receiver) = ws_stream.split();

            while let Some(msg) = receiver.next().await {                match msg {                    Ok(Message::Text(text)) => {                        println!("{} से संदेश: {}", addr, text);                        sender.send(Message::Text(format!("इको: {}", text))).await.unwrap();                    }                    Ok(Message::Close(_)) => break,                    _ => {}                }            }

            println!("{} से कनेक्शन बंद हुआ", addr);        });    }}

लाइब्रेरीज़ की मुख्य विशेषताएं

• TLS/SSL समर्थन — WSS के माध्यम से सुरक्षित कनेक्शन (feature tls सक्षम करना आवश्यक है)
• स्वचालित पुनः कनेक्शन — लूप और टाइमर का उपयोग करके कार्यान्वित किया जा सकता है
• पिंग/पोंग फ्रेम — कनेक्शन बनाए रखने के लिए
• बाइनरी संदेश — Message::Binary के साथ काम करना