tokio_websocket_server 0.1.0

A robust WebSocket server implementation with TLS support built on Tokio
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

pub mod socket;

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn start_websocket() {
        use crate::socket::{WebSocketMessage, WebsocketServer};
        // Create WebSocket server
        let ws_server = WebsocketServer::new("0.0.0.0".to_string(), "5000".to_string(), None, None);

        // Get a clone of the server for use in the main application
        let ws_server_clone = ws_server.clone();

        // Start the WebSocket server and get the message receiver
        let mut ws_message_receiver = ws_server.start().await;

        // Handle incoming WebSocket messages in a separate task
        // Remove this if you want to make the task blocking
        tokio::spawn(async move { 
            while let Some((client_id, message)) = ws_message_receiver.recv().await {
                match message {
                    WebSocketMessage::Text(text) => {
                        tracing::info!("Received text message from {}: {}", client_id, text);

                        // Perform business logic

                        // Echo the message back to the sender
                        let response = WebSocketMessage::Text(format!("Echo: {}", text));

                        if let Err(e) = ws_server_clone
                            .send_to_client(client_id.clone(), response)
                            .await
                        {
                            tracing::error!("Failed to respond to client {}: {}", client_id, e);
                        }
                    }
                    WebSocketMessage::Binary(data) => {
                        tracing::info!(
                            "Received binary message from {}: {} bytes",
                            client_id,
                            data.len()
                        );

                        // Perform business logic

                        // Echo binary data back
                        let response = WebSocketMessage::Binary(data);

                        if let Err(e) = ws_server_clone
                            .send_to_client(client_id.clone(), response)
                            .await
                        {
                            tracing::error!("Failed to respond to client {}: {}", client_id, e);
                        }
                    }
                    WebSocketMessage::Ping(_data) => {
                        // Automatically respond with Pong (already handled in the implementation)
                        tracing::info!("Ping received from client {}", client_id);
                    }
                    WebSocketMessage::Close(_) => {
                        tracing::info!("Client {} requested to close connection", client_id);
                    }
                    _ => {
                        tracing::info!(
                            "Received other message type from {}: {:?}",
                            client_id,
                            message
                        );
                    }
                }
            }
        });
    }
}