kimojio 0.16.2

A thread-per-core Linux io_uring async runtime optimized for latency.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use rustix_uring::Errno;

/// An error that is returned when attempting to receive a message from a
/// channel that has been closed.
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub enum ChannelError {
    Closed,
    Canceled,
    Timeout,
}

impl std::fmt::Display for ChannelError {
    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        "receiving on a closed channel".fmt(fmt)
    }
}

impl std::error::Error for ChannelError {}

impl From<ChannelError> for Errno {
    fn from(value: ChannelError) -> Self {
        match value {
            ChannelError::Closed => Errno::PIPE,
            ChannelError::Canceled => Errno::CANCELED,
            ChannelError::Timeout => Errno::TIME,
        }
    }
}

impl From<CanceledError> for ChannelError {
    fn from(_: CanceledError) -> Self {
        ChannelError::Canceled
    }
}

impl From<TimeoutError> for ChannelError {
    fn from(e: TimeoutError) -> Self {
        match e {
            TimeoutError::Timeout => ChannelError::Timeout,
            TimeoutError::Canceled => ChannelError::Canceled,
        }
    }
}

/// An error indicating an operation timed out or was canceled.
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum TimeoutError {
    /// The operation exceeded its deadline.
    Timeout,
    /// The operation was canceled.
    Canceled,
}

impl From<CanceledError> for TimeoutError {
    fn from(_: CanceledError) -> Self {
        TimeoutError::Canceled
    }
}

impl From<TimeoutError> for Errno {
    fn from(err: TimeoutError) -> Self {
        match err {
            TimeoutError::Timeout => Errno::TIMEDOUT,
            TimeoutError::Canceled => Errno::CANCELED,
        }
    }
}

/// An error indicating an operation was canceled.
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct CanceledError {}

impl From<CanceledError> for Errno {
    fn from(_: CanceledError) -> Self {
        Errno::CANCELED
    }
}

/// An error from awaiting a task handle.
pub enum TaskHandleError {
    /// The task was canceled before completion.
    Canceled,
    /// The task panicked during execution.
    Panic(Box<dyn std::any::Any + Send + 'static>),
}

impl std::fmt::Debug for TaskHandleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TaskHandleError::Canceled => write!(f, "TaskHandleError::Canceled"),
            TaskHandleError::Panic(_) => write!(f, "TaskHandleError::Panic"),
        }
    }
}

/// This will propagate panics if the task panicked, and otherwise return
/// Result<T, Errno>.
pub fn errno_from_task_handle_result<R>(
    result: Result<Result<R, Errno>, TaskHandleError>,
) -> Result<R, Errno> {
    match result {
        Ok(result) => result,
        Err(TaskHandleError::Canceled) => Err(Errno::CANCELED),
        Err(TaskHandleError::Panic(payload)) => std::panic::resume_unwind(payload),
    }
}