WebSocket RS Documentation

[dependencies]
websocket-rs = "0.1.0"
tokio = { version = "1.0", features = ["full"] }

cargo add websocket-rs
cargo add tokio --features full

use websocket_rs::{WebSocketServer, Message};

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Create server instance
    let mut server = WebSocketServer::new("127.0.0.1:8080");
    
    println!("WebSocket server running on ws://127.0.0.1:8080");
    
    // Start the server
    server.start(|client_id, message| {
        println!("Client {}: {}", client_id, message);
        
        // Echo the message back
        Message::Text(format!("Echo: {}", message))
    }).await?;
    
    Ok(())
}

use websocket_rs::WebSocketServer;

let server = WebSocketServer::new("0.0.0.0:8080");
// Server is now ready to accept connections

use websocket_rs::{WebSocketServer, Config};

let config = Config {
    max_connections: 1000,
    ping_interval: Duration::from_secs(30),
    timeout: Duration::from_secs(60),
};

let server = WebSocketServer::with_config("0.0.0.0:8080", config);

// Create WebSocket connection
const ws = new WebSocket('ws://localhost:8080');

// Connection opened
ws.addEventListener('open', (event) => {
    console.log('Connected to server');
    ws.send('Hello Server!');
});

// Listen for messages
ws.addEventListener('message', (event) => {
    console.log('Message from server:', event.data);
});

// Connection closed
ws.addEventListener('close', (event) => {
    console.log('Disconnected from server');
});

// Handle errors
ws.addEventListener('error', (error) => {
    console.error('WebSocket error:', error);
});

use websocket_rs::WebSocketClient;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = WebSocketClient::connect("ws://localhost:8080").await?;
    
    // Send a message
    client.send("Hello Server!").await?;
    
    // Receive messages
    while let Some(msg) = client.receive().await? {
        println!("Received: {}", msg);
    }
    
    Ok(())
}

server.on_message(|client_id, message| {
    match message {
        Message::Text(text) => {
            println!("Text from {}: {}", client_id, text);
            // Process text message
        },
        Message::Binary(data) => {
            println!("Binary data from {}: {} bytes", client_id, data.len());
            // Process binary data
        },
        _ => {}
    }
});

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct ChatMessage {
    user: String,
    content: String,
    timestamp: u64,
}

server.on_message(|client_id, message| {
    if let Message::Text(text) = message {
        if let Ok(chat_msg) = serde_json::from_str::(&text) {
            println!("{} says: {}", chat_msg.user, chat_msg.content);
        }
    }
});

// Broadcast a message to all connected clients
server.broadcast("Server announcement!").await?;

// Send to specific client
server.send_to(client_id, "Private message").await?;

// Send to multiple clients
let client_ids = vec![1, 2, 3];
server.broadcast_to(client_ids, "Group message").await?;

use std::collections::HashMap;

let mut rooms: HashMap> = HashMap::new();

server.on_message(move |client_id, message| {
    if let Message::Text(text) = message {
        // Parse command
        if text.starts_with("/join ") {
            let room = text[6..].to_string();
            rooms.entry(room.clone())
                .or_insert_with(Vec::new)
                .push(client_id);
        } else {
            // Broadcast to room members
            if let Some(room_members) = rooms.get(¤t_room) {
                server.broadcast_to(room_members.clone(), text).await?;
            }
        }
    }
});

server.on_error(|client_id, error| {
    eprintln!("Error with client {}: {}", client_id, error);
});

server.on_close(|client_id| {
    println!("Client {} disconnected", client_id);
});

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
enum CustomMessage {
    Join { username: String },
    Leave { username: String },
    Chat { user: String, message: String },
    Typing { user: String },
}

server.on_message(|client_id, message| {
    if let Message::Text(text) = message {
        match serde_json::from_str::(&text) {
            Ok(custom_msg) => match custom_msg {
                CustomMessage::Join { username } => {
                    println!("{} joined", username);
                },
                CustomMessage::Chat { user, message } => {
                    server.broadcast(format!("{}: {}", user, message)).await?;
                },
                _ => {}
            },
            Err(e) => eprintln!("Failed to parse message: {}", e),
        }
    }
});

server.on_connect(|client_id, request| {
    // Verify token from query parameter
    if let Some(token) = request.query("token") {
        if verify_token(token) {
            println!("Client {} authenticated", client_id);
            return Ok(());
        }
    }
    
    Err("Unauthorized")
});

use std::collections::HashMap;
use std::time::{Duration, Instant};

struct RateLimiter {
    limits: HashMap,
    max_per_minute: u32,
}

impl RateLimiter {
    fn check(&mut self, client_id: usize) -> bool {
        let now = Instant::now();
        let entry = self.limits.entry(client_id)
            .or_insert((0, now));
        
        if now.duration_since(entry.1) > Duration::from_secs(60) {
            entry.0 = 1;
            entry.1 = now;
            true
        } else if entry.0 < self.max_per_minute {
            entry.0 += 1;
            true
        } else {
            false
        }
    }
}