completeio 0.1.0

Completion based IO drivers and async runtime
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
97
98
99
100
101
102
103

use std::net::{IpAddr, SocketAddr};

use completeio::net::{TcpListener, TcpStream, ToSockAddrs};

async fn test_connect_ip_impl(
    target: impl ToSockAddrs,
    assert_fn: impl FnOnce(&SocketAddr) -> bool,
) {
    let listener = TcpListener::bind(target).unwrap();
    let addr = listener.local_addr().unwrap();
    assert!(assert_fn(&addr.as_socket().unwrap()));

    let (tx, rx) = futures_channel::oneshot::channel();

    completeio::task::spawn(async move {
        let (socket, addr) = listener.accept().await.unwrap();
        assert_eq!(addr, socket.peer_addr().unwrap());
        assert!(tx.send(socket).is_ok());
    })
    .detach();

    let mine = TcpStream::connect(&addr).await.unwrap();
    let theirs = rx.await.unwrap();

    assert_eq!(mine.local_addr().unwrap(), theirs.peer_addr().unwrap());
    assert_eq!(theirs.local_addr().unwrap(), mine.peer_addr().unwrap());
}

macro_rules! test_connect_ip {
    ($(($ident:ident, $target:expr, $addr_f:path),)*) => {
        $(
            #[test]
             fn $ident() {
                completeio::task::block_on(test_connect_ip_impl($target, $addr_f))
            }
        )*
    }
}

test_connect_ip! {
    (connect_v4, "127.0.0.1:0", SocketAddr::is_ipv4),
    (connect_v6, "[::1]:0", SocketAddr::is_ipv6),
}

async fn test_connect_impl<A: ToSockAddrs>(mapping: impl FnOnce(&TcpListener) -> A) {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let addr = mapping(&listener);
    let server = async {
        listener.accept().await.unwrap();
    };

    let client = async {
        match TcpStream::connect(addr).await {
            Ok(_) => (),
            Err(e) => panic!("Failed to connect: {}", e),
        }
    };

    futures_util::join!(server, client);
}

macro_rules! test_connect {
    ($(($ident:ident, $mapping:tt),)*) => {
        $(
            #[test]
            fn $ident() {
                #[allow(unused_parens)]
                completeio::task::block_on(test_connect_impl($mapping))
            }
        )*
    }
}

test_connect! {
    (ip_string, (|listener: &TcpListener| {
        format!("127.0.0.1:{}", listener.local_addr().unwrap().as_socket().unwrap().port())
    })),
    (ip_str, (|listener: &TcpListener| {
        let s = format!("127.0.0.1:{}", listener.local_addr().unwrap().as_socket().unwrap().port());
        let slice: &str = &*Box::leak(s.into_boxed_str());
        slice
    })),
    (ip_port_tuple, (|listener: &TcpListener| {
        let addr = listener.local_addr().unwrap().as_socket().unwrap();
        (addr.ip(), addr.port())
    })),
    (ip_port_tuple_ref, (|listener: &TcpListener| {
        let addr = listener.local_addr().unwrap().as_socket().unwrap();
        let tuple_ref: &(IpAddr, u16) = &*Box::leak(Box::new((addr.ip(), addr.port())));
        tuple_ref
    })),
    (ip_str_port_tuple, (|listener: &TcpListener| {
        let addr = listener.local_addr().unwrap().as_socket().unwrap();
        ("127.0.0.1", addr.port())
    })),
}

#[test]
fn connect_invalid_dst() {
    completeio::task::block_on(async {
        assert!(TcpStream::connect("127.0.0.1:1").await.is_err());
    })
}