Skip to main content

qualia_core_db/net/peer/runtime/
events.rs

1//! Bounded kernel events and effects. Completion consumes the slot.
2
3use crate::net::qdnf::errors::QdnfError;
4use crate::net::qdnf::types::OperationId;
5
6use super::handles::LeaseHandle;
7
8#[repr(u8)]
9#[derive(Clone, Copy, Debug, PartialEq, Eq)]
10pub enum EventKind {
11    FrameReceived = 1,
12    Timer = 2,
13    CryptoComplete = 3,
14    Cancel = 4,
15}
16
17#[repr(u8)]
18#[derive(Clone, Copy, Debug, PartialEq, Eq)]
19pub enum EffectKind {
20    SendFrame = 1,
21    CryptoWork = 2,
22    DurableCommit = 3,
23    ReleaseLease = 4,
24}
25
26#[repr(C)]
27#[derive(Clone, Copy, Debug, PartialEq, Eq)]
28pub struct KernelEvent {
29    pub kind: EventKind,
30    pub operation: OperationId,
31    pub lease: LeaseHandle,
32}
33
34#[repr(C)]
35#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub struct KernelEffect {
37    pub kind: EffectKind,
38    pub operation: OperationId,
39    pub lease: LeaseHandle,
40}
41
42#[derive(Clone, Copy)]
43struct EffectSlot {
44    effect: KernelEffect,
45    cancelled: bool,
46}
47
48pub struct EffectQueue {
49    slots: [Option<EffectSlot>; 16],
50    len: usize,
51}
52
53impl EffectQueue {
54    /// Creates a default `EffectQueue`.
55    pub const fn new() -> Self {
56        Self {
57            slots: [None; 16],
58            len: 0,
59        }
60    }
61
62    /// Pushes an event.
63    pub fn push(&mut self, effect: KernelEffect) -> Result<(), QdnfError> {
64        if self.len >= self.slots.len() {
65            return Err(QdnfError::Capacity);
66        }
67        self.slots[self.len] = Some(EffectSlot {
68            effect,
69            cancelled: false,
70        });
71        self.len += 1;
72        Ok(())
73    }
74
75    /// Mark in-flight effects for `operation`. Later `complete` consumes the
76    /// slot (releases storage) but returns `Cancelled` so the op cannot revive.
77    pub fn cancel_in_flight(&mut self, operation: OperationId) -> Result<(), QdnfError> {
78        let mut found = false;
79        for i in 0..self.len {
80            if let Some(slot) = &mut self.slots[i] {
81                if slot.effect.operation == operation {
82                    slot.cancelled = true;
83                    found = true;
84                }
85            }
86        }
87        if found {
88            Ok(())
89        } else {
90            Err(QdnfError::WouldBlock)
91        }
92    }
93
94    /// Consuming completion: the effect leaves the queue.
95    pub fn complete(&mut self) -> Result<KernelEffect, QdnfError> {
96        if self.len == 0 {
97            return Err(QdnfError::WouldBlock);
98        }
99        let slot = self.slots[0].take().ok_or(QdnfError::Malformed)?;
100        for i in 0..self.len - 1 {
101            self.slots[i] = self.slots[i + 1];
102        }
103        self.len -= 1;
104        self.slots[self.len] = None;
105        if slot.cancelled {
106            Err(QdnfError::Cancelled)
107        } else {
108            Ok(slot.effect)
109        }
110    }
111
112    /// Number of elements.
113    pub fn len(&self) -> usize {
114        self.len
115    }
116}
117
118impl Default for EffectQueue {
119    fn default() -> Self {
120        Self::new()
121    }
122}
123
124#[cfg(test)]
125mod tests {
126    use super::*;
127
128    fn effect(n: u8) -> KernelEffect {
129        let mut id = [0u8; 16];
130        id[0] = n;
131        KernelEffect {
132            kind: EffectKind::SendFrame,
133            operation: OperationId(id),
134            lease: LeaseHandle::INVALID,
135        }
136    }
137
138    #[test]
139    fn complete_consumes_slot() {
140        let mut q = EffectQueue::new();
141        q.push(effect(1)).unwrap();
142        q.push(effect(2)).unwrap();
143        assert_eq!(q.complete().unwrap().operation.0[0], 1);
144        assert_eq!(q.len(), 1);
145        assert_eq!(q.complete().unwrap().operation.0[0], 2);
146        assert_eq!(q.complete(), Err(QdnfError::WouldBlock));
147    }
148
149    #[test]
150    fn cancel_in_flight_rejects_late_complete() {
151        let mut q = EffectQueue::new();
152        let e = effect(7);
153        q.push(e).unwrap();
154        q.cancel_in_flight(e.operation).unwrap();
155        assert_eq!(q.complete(), Err(QdnfError::Cancelled));
156        assert_eq!(q.len(), 0);
157        assert_eq!(q.complete(), Err(QdnfError::WouldBlock));
158    }
159}