qualia_core_db/net/peer/runtime/
events.rs1use 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 pub const fn new() -> Self {
56 Self {
57 slots: [None; 16],
58 len: 0,
59 }
60 }
61
62 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 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 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 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}