compio-net 0.11.1

Networking IO for compio
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

use compio_net::UdpSocket;

#[compio_macros::test]
async fn connect() {
    const MSG: &str = "foo bar baz";

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.connect(passive_addr).await.unwrap();
    active.send(MSG).await.0.unwrap();

    let (_, buffer) = passive.recv(Vec::with_capacity(20)).await.unwrap();
    assert_eq!(MSG.as_bytes(), &buffer);
    assert_eq!(active.local_addr().unwrap(), active_addr);
    assert_eq!(active.peer_addr().unwrap(), passive_addr);
}

#[compio_macros::test]
async fn send_to() {
    const MSG: &str = "foo bar baz";

    macro_rules! must_success {
        ($r:expr, $expect_addr:expr) => {
            let res = $r;
            assert_eq!(res.0.unwrap().1, $expect_addr);
            assert_eq!(res.1, MSG.as_bytes());
        };
    }

    let passive1 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive1_addr = passive1.local_addr().unwrap();

    let passive01 = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
    let passive01_addr = passive01.local_addr().unwrap();

    let passive2 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive2_addr = passive2.local_addr().unwrap();

    let passive3 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive3_addr = passive3.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.send_to(MSG, &passive01_addr).await.0.unwrap();
    active.send_to(MSG, &passive1_addr).await.0.unwrap();
    active.send_to(MSG, &passive2_addr).await.0.unwrap();
    active.send_to(MSG, &passive3_addr).await.0.unwrap();

    must_success!(
        passive1.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
    must_success!(
        passive2.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
    must_success!(
        passive3.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
}

#[compio_macros::test]
async fn send_recv_vectored() {
    const MSG1: &str = "foobar";
    const MSG2: [u8; 5] = [1, 2, 3, 4, 5];
    let msg2: Vec<u8> = Vec::from(MSG2);

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.connect(passive_addr).await.unwrap();
    active.send_vectored((MSG1, (msg2,))).await.0.unwrap();

    let recv_buf: [u8; 6] = [0; 6];
    let (_, buffer) = passive
        .recv_vectored((recv_buf, (Vec::with_capacity(20),)))
        .await
        .unwrap();

    assert_eq!(MSG1.as_bytes(), &buffer.0);
    assert_eq!(MSG2, buffer.1.0.as_slice());
    assert_eq!(active.local_addr().unwrap(), active_addr);
    assert_eq!(active.peer_addr().unwrap(), passive_addr);
}