a10 0.4.2

This library is meant as a low-level library safely exposing different OS's abilities to perform non-blocking I/O.
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

#[cfg(any(target_os = "android", target_os = "linux"))]
use std::thread;
#[cfg(any(target_os = "android", target_os = "linux"))]
use std::time::Duration;

use a10::Config;
#[cfg(any(target_os = "android", target_os = "linux"))]
use a10::Ring;
#[cfg(any(target_os = "android", target_os = "linux"))]
use a10::io::ReadBufPool;

#[cfg(any(target_os = "android", target_os = "linux"))]
use crate::util::{expect_io_errno, init};
use crate::util::{is_send, is_sync};

#[cfg(any(target_os = "android", target_os = "linux"))]
const BUF_SIZE: usize = 4096;

#[test]
fn config_is_send_and_sync() {
    is_send::<Config>();
    is_sync::<Config>();
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn config_disabled() {
    init();
    let mut ring = Ring::config().disable().build().unwrap();

    // In a disabled state, so we expect an error.
    expect_io_errno(ring.poll(None), libc::EBADFD);

    // Enabling it should allow us to poll.
    ring.enable().unwrap();
    ring.poll(Some(Duration::from_millis(1))).unwrap();
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn config_single_issuer() {
    init();

    let ring = Ring::config().single_issuer().build().unwrap();

    // This is fine.
    let buf_pool = ReadBufPool::new(ring.sq().clone(), 2, BUF_SIZE as u32).unwrap();
    drop(buf_pool);

    thread::spawn(move || {
        // This is not (we're on a different thread).
        let res = ReadBufPool::new(ring.sq().clone(), 2, BUF_SIZE as u32);
        expect_io_errno(res, libc::EEXIST);
    })
    .join()
    .unwrap();
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn config_single_issuer_disabled_ring() {
    init();

    let mut ring = Ring::config().single_issuer().disable().build().unwrap();

    thread::spawn(move || {
        ring.enable().unwrap();

        // Since this thread enabled the ring, this is now fine.
        let buf_pool = ReadBufPool::new(ring.sq().clone(), 2, BUF_SIZE as u32).unwrap();
        drop(buf_pool);
    })
    .join()
    .unwrap();
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn config_defer_task_run() {
    init();

    let mut ring = Ring::config()
        .single_issuer()
        .defer_task_run()
        .build()
        .unwrap();

    ring.poll(Some(Duration::ZERO)).unwrap();
}