hala-io 0.1.6

hala asynchronous io programming primitive types
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::sync::OnceLock;

use crate::{Driver, Handle};

/// Io context must implement this trait.
pub trait RawIoContext {
    /// Get driver reference of this context.
    fn driver(&self) -> &Driver;

    /// Get poller handle of this context
    fn poller(&self) -> Handle;
}

/// Only feature "mio-driver" valid
#[cfg(feature = "mio-driver")]
mod default_context {
    use std::{
        io,
        sync::{
            atomic::{AtomicBool, Ordering},
            Arc,
        },
        thread::JoinHandle,
    };

    use super::RawIoContext;

    use crate::{mio::mio_driver, Cmd, Description, Driver, Handle};

    /// Hala io context implement with `mio` crate.
    pub struct MioContext {
        driver: Driver,
        poller: Handle,
        flag: Arc<AtomicBool>,
        join_handle: Option<JoinHandle<()>>,
    }

    impl MioContext {
        /// Create new default [`MioContext`] instance.
        pub fn new() -> io::Result<Self> {
            let driver = mio_driver();

            let poller = driver.fd_open(Description::Poller, crate::OpenFlags::None)?;

            let flag: Arc<AtomicBool> = Default::default();

            let flag_cloned = flag.clone();

            let driver_cloned = driver.clone();

            let join_handle = std::thread::spawn(move || {
                while !flag_cloned.load(Ordering::Acquire) {
                    driver_cloned.fd_cntl(poller, Cmd::PollOnce(None)).unwrap();
                }
            });

            Ok(Self {
                driver,
                poller,
                flag,
                join_handle: Some(join_handle),
            })
        }
    }

    impl Drop for MioContext {
        fn drop(&mut self) {
            self.flag.store(true, Ordering::Release);
            self.join_handle.take().unwrap().join().unwrap();
        }
    }

    impl RawIoContext for MioContext {
        fn driver(&self) -> &Driver {
            &self.driver
        }

        fn poller(&self) -> Handle {
            self.poller
        }
    }
}

pub struct IoContext(Box<dyn RawIoContext + Send + Sync + 'static>);

impl RawIoContext for IoContext {
    fn driver(&self) -> &Driver {
        self.0.driver()
    }

    fn poller(&self) -> Handle {
        self.0.poller()
    }
}

static REGISTER: OnceLock<IoContext> = OnceLock::new();

/// Register global [`IoContext`].
///
/// Notice: call this function tiwce will panic !!!
pub fn register_io_context<C: RawIoContext + Send + Sync + 'static>(context: C) {
    if REGISTER.set(IoContext(Box::new(context))).is_err() {
        panic!("Register io context twice");
    }
}

/// Get global register [`IoContext`].
///
/// Notice: this function must be called after a call [`register_io_context`], otherwise panic will occur.
/// or the `mio-driver` is available
pub fn io_context() -> &'static IoContext {
    #[cfg(feature = "mio-driver")]
    return REGISTER
        .get_or_init(|| IoContext(Box::new(default_context::MioContext::new().unwrap())));

    #[cfg(not(feature = "mio-driver"))]
    REGISTER
        .get()
        .as_ref()
        .expect("Call register_io_context first")
}