muchin 0.1.0

Support for composing large, interacting, complicated state machines
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use crate::automaton::{Action, ActionKind, Redispatch, Timeout, Uid};
use serde::{Deserialize, Serialize};
use std::rc::Rc;
use type_uuid::TypeUuid;

/// `MioAction` is an enum representing various I/O related operations
/// that can be performed. These actions are dispatched for handling by the
/// `MioState` model. Each action variant includes the necessary parameters
/// for the operation and a callback `Redispatch` to dispatch the result
/// of the operation back to the caller Model.
///
/// Operations include:
/// - Poll creation, registration, and deregistration.
/// - TCP server and connection management: listen, accept, connect, close.
/// - Data transmission over TCP: write, read.
/// - Miscellaneous: event creation, polling events, getting peer address.
///
/// Note: `Uid` is used to uniquely identify instances of various Model-
/// specific objects like polls, connections, events etc.

#[derive(Clone, PartialEq, Eq, TypeUuid, Serialize, Deserialize, Debug)]
#[uuid = "6ade1356-d5fe-4c28-8fa9-fe4ee2fffc5f"]
pub enum MioEffectfulAction {
    PollCreate {
        poll: Uid,
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    PollRegisterTcpServer {
        poll: Uid,     // created by PollCreate
        listener: Uid, // created by TcpListen
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    PollRegisterTcpConnection {
        poll: Uid,       // created by PollCreate
        connection: Uid, // created by TcpAccept/TcpConnect
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    PollDeregisterTcpConnection {
        poll: Uid,       // created by PollCreate
        connection: Uid, // created by TcpAccept/TcpConnect
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    PollEvents {
        uid: Uid,    // passed back to call-back action to identify the request
        poll: Uid,   // created by PollCreate
        events: Uid, // created by EventsCreate
        timeout: Timeout,
        on_success: Redispatch<(Uid, Vec<MioEvent>)>,
        on_interrupted: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    EventsCreate {
        uid: Uid,
        capacity: usize,
        on_success: Redispatch<Uid>,
    },
    TcpListen {
        listener: Uid,
        address: String,
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    TcpAccept {
        connection: Uid,
        listener: Uid, // created by TcpListen
        on_success: Redispatch<Uid>,
        on_would_block: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    TcpConnect {
        connection: Uid,
        address: String,
        on_success: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    TcpClose {
        connection: Uid, // created by TcpAccept/TcpConnect
        on_success: Redispatch<Uid>,
    },
    TcpWrite {
        uid: Uid,        // passed back to call-back action to identify the request
        connection: Uid, // created by TcpAccept/TcpConnect

        // Strictly speaking, we should pass a copy here instead of referencing memory,
        // but the Rc guarantees immutability, allowing safe and efficient data sharing.
        #[serde(
            serialize_with = "crate::automaton::serialize_rc_bytes",
            deserialize_with = "crate::automaton::deserialize_rc_bytes"
        )]
        data: Rc<[u8]>,
        on_success: Redispatch<Uid>,
        on_success_partial: Redispatch<(Uid, usize)>,
        on_interrupted: Redispatch<Uid>,
        on_would_block: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    TcpRead {
        uid: Uid,        // passed back to call-back action to identify the request
        connection: Uid, // created by TcpAccept/TcpConnect
        len: usize,      // max number of bytes to read
        on_success: Redispatch<(Uid, Vec<u8>)>,
        on_success_partial: Redispatch<(Uid, Vec<u8>)>,
        on_interrupted: Redispatch<Uid>,
        on_would_block: Redispatch<Uid>,
        on_error: Redispatch<(Uid, String)>,
    },
    TcpGetPeerAddress {
        connection: Uid, // created by TcpAccept/TcpConnect
        on_success: Redispatch<(Uid, String)>,
        on_error: Redispatch<(Uid, String)>,
    },
}

impl Action for MioEffectfulAction {
    const KIND: ActionKind = ActionKind::Effectful;
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum TcpWriteResult {
    WrittenAll,
    WrittenPartial(usize),
    Interrupted,
    WouldBlock,
    Error(String),
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum TcpReadResult {
    ReadAll(Vec<u8>),
    ReadPartial(Vec<u8>),
    Interrupted,
    WouldBlock,
    Error(String),
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum TcpAcceptResult {
    Success,
    WouldBlock,
    Error(String),
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub struct MioEvent {
    pub token: Uid,
    pub readable: bool,
    pub writable: bool,
    pub error: bool,
    pub read_closed: bool,
    pub write_closed: bool,
    pub priority: bool,
    pub aio: bool,
    pub lio: bool,
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
pub enum PollResult {
    Events(Vec<MioEvent>),
    Interrupted,
    Error(String),
}