udp 3.1.0

A lightweight and efficient Rust library for building UDP servers with request-response handling.
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use crate::*;

#[derive(Clone)]
struct EchoHandler;

impl ServerHook for EchoHandler {
    async fn new(_ctx: &Context) -> Self {
        Self
    }

    async fn handle(self, ctx: &Context) {
        let request: Request = ctx.get_request().await;
        let response: String = format!("Echo: {request:?}");
        let _ = ctx.send(response).await;
    }
}

#[derive(Clone)]
struct PanicHandler;

impl ServerHook for PanicHandler {
    async fn new(_ctx: &Context) -> Self {
        Self
    }

    async fn handle(self, _ctx: &Context) {
        println!("A task panic occurred");
    }
}

#[tokio::test]
async fn test_server_with_struct_handler() {
    let server_config: ServerConfig = ServerConfig::new().await;
    server_config.host("127.0.0.1").await;
    server_config.port(0).await;
    server_config.buffer_size(65535).await;
    let server: Server = Server::new().await;
    server.server_config(server_config).await;
    server.hook::<EchoHandler>().await;
    server.task_panic::<PanicHandler>().await;
}

#[tokio::test]
async fn test_server_config() {
    let config: ServerConfig = ServerConfig::new().await;
    config.host("127.0.0.1").await;
    config.port(8080).await;
    config.buffer_size(1024).await;
    let data: ServerConfigData = config.get_data().await;
    assert_eq!(data.get_host(), "127.0.0.1");
    assert_eq!(data.get_port(), 8080);
    assert_eq!(data.get_buffer_size(), 1024);
}

#[tokio::test]
async fn test_context_creation() {
    let socket: UdpSocket = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let socket: ArcRwLockUdpSocket = ArcRwLockUdpSocket::from_socket(socket);
    let request: Request = vec![1, 2, 3, 4];
    let client_addr: SocketAddr = SocketAddr::from(([127, 0, 0, 1], 12345));
    let ctx: Context = Context::new(&socket, &request, client_addr);
    assert_eq!(ctx.get_request().await, request);
    assert_eq!(ctx.get_client_addr().await, client_addr);
}

#[tokio::test]
async fn test_server_run_and_shutdown() {
    #[derive(Clone)]
    struct TestHandler;

    impl ServerHook for TestHandler {
        async fn new(_ctx: &Context) -> Self {
            Self
        }

        async fn handle(self, ctx: &Context) {
            let _ = ctx.send("test response").await;
        }
    }

    let server_config: ServerConfig = ServerConfig::new().await;
    server_config.host("127.0.0.1").await;
    server_config.port(60000).await;
    server_config.buffer_size(65535).await;
    let server: Server = Server::new().await;
    server.server_config(server_config).await;
    server.hook::<TestHandler>().await;

    let server_control_hook_1: ServerControlHook = server.run().await.unwrap_or_default();
    let server_control_hook_2: ServerControlHook = server_control_hook_1.clone();
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
        server_control_hook_2.shutdown().await;
    });
    server_control_hook_1.wait().await;
}