qualia_core_db/net/peer/connectivity/
durable.rs1#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4pub enum Delivery {
5 QueuedLocally,
6 AcceptedByCustodian,
7 ReceivedByEndpoint,
8 AppliedDurably,
9 Expired,
10 Unavailable,
11}
12
13pub const MAX_JOBS: usize = 8;
14pub const MAX_BLOB: usize = 256;
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17pub struct DurableJob {
18 pub op_id: u64,
19 pub expiry_unix: u32,
20 pub state: Delivery,
21 pub len: u16,
22 pub blob: [u8; MAX_BLOB],
23}
24
25impl DurableJob {
26 pub const fn empty() -> Self {
28 Self {
29 op_id: 0,
30 expiry_unix: 0,
31 state: Delivery::Unavailable,
32 len: 0,
33 blob: [0u8; MAX_BLOB],
34 }
35 }
36}
37
38#[derive(Debug, Clone, Copy, PartialEq, Eq)]
39pub struct DurableQueue {
40 jobs: [DurableJob; MAX_JOBS],
41 len: usize,
42}
43
44impl DurableQueue {
45 pub const fn new() -> Self {
47 Self {
48 jobs: [DurableJob::empty(); MAX_JOBS],
49 len: 0,
50 }
51 }
52
53 pub fn enqueue(&mut self, op_id: u64, expiry_unix: u32, payload: &[u8]) -> Result<usize, ()> {
55 if payload.len() > MAX_BLOB || self.len >= MAX_JOBS {
56 return Err(());
57 }
58 let mut i = 0;
59 while i < self.len {
60 if self.jobs[i].op_id == op_id {
61 return Ok(i);
62 }
63 i += 1;
64 }
65 let mut job = DurableJob::empty();
66 job.op_id = op_id;
67 job.expiry_unix = expiry_unix;
68 job.state = Delivery::QueuedLocally;
69 job.len = payload.len() as u16;
70 job.blob[..payload.len()].copy_from_slice(payload);
71 self.jobs[self.len] = job;
72 let idx = self.len;
73 self.len += 1;
74 Ok(idx)
75 }
76
77 pub fn mark_relay_write(&self) -> Delivery {
79 Delivery::QueuedLocally
80 }
81
82 pub fn advance(&mut self, op_id: u64, to: Delivery, now_unix: u32) -> Result<(), ()> {
84 let i = self.find(op_id).ok_or(())?;
85 if now_unix >= self.jobs[i].expiry_unix {
86 self.jobs[i].state = Delivery::Expired;
87 return Ok(());
88 }
89 if !legal(self.jobs[i].state, to) {
90 return Err(());
91 }
92 self.jobs[i].state = to;
93 Ok(())
94 }
95
96 pub fn expire_due(&mut self, now_unix: u32) -> usize {
98 let mut n = 0;
99 let mut i = 0;
100 while i < self.len {
101 if self.jobs[i].state != Delivery::AppliedDurably
102 && self.jobs[i].state != Delivery::Expired
103 && now_unix >= self.jobs[i].expiry_unix
104 {
105 self.jobs[i].state = Delivery::Expired;
106 n += 1;
107 }
108 i += 1;
109 }
110 n
111 }
112
113 pub fn state_of(&self, op_id: u64) -> Option<Delivery> {
115 self.find(op_id).map(|i| self.jobs[i].state)
116 }
117
118 pub(crate) fn len(&self) -> usize {
120 self.len
121 }
122
123 pub(crate) fn job_at(&self, i: usize) -> Option<DurableJob> {
125 if i < self.len {
126 Some(self.jobs[i])
127 } else {
128 None
129 }
130 }
131
132 pub(crate) fn restore(&mut self, job: DurableJob) -> Result<(), ()> {
134 if self.len >= MAX_JOBS {
135 return Err(());
136 }
137 self.jobs[self.len] = job;
138 self.len += 1;
139 Ok(())
140 }
141
142 fn find(&self, op_id: u64) -> Option<usize> {
143 let mut i = 0;
144 while i < self.len {
145 if self.jobs[i].op_id == op_id {
146 return Some(i);
147 }
148 i += 1;
149 }
150 None
151 }
152}
153
154fn legal(from: Delivery, to: Delivery) -> bool {
155 use Delivery::*;
156 matches!(
157 (from, to),
158 (QueuedLocally, AcceptedByCustodian)
159 | (QueuedLocally, Expired)
160 | (QueuedLocally, Unavailable)
161 | (AcceptedByCustodian, ReceivedByEndpoint)
162 | (AcceptedByCustodian, Expired)
163 | (AcceptedByCustodian, Unavailable)
164 | (ReceivedByEndpoint, AppliedDurably)
165 | (ReceivedByEndpoint, Expired)
166 )
167}
168
169#[cfg(test)]
170mod tests {
171 use super::*;
172
173 #[test]
174 fn relay_write_is_not_delivered() {
175 let q = DurableQueue::new();
176 assert_eq!(q.mark_relay_write(), Delivery::QueuedLocally);
177 }
178
179 #[test]
180 fn ram_dedup_and_expiry_is_not_persistence() {
181 let mut q = DurableQueue::new();
182 assert_eq!(q.enqueue(9, 100, b"op").unwrap(), 0);
183 assert_eq!(q.enqueue(9, 100, b"op").unwrap(), 0);
184 q.advance(9, Delivery::AcceptedByCustodian, 50).unwrap();
185 q.advance(9, Delivery::ReceivedByEndpoint, 50).unwrap();
186 q.advance(9, Delivery::AppliedDurably, 50).unwrap();
187 assert_eq!(q.state_of(9), Some(Delivery::AppliedDurably));
188 let mut q2 = DurableQueue::new();
189 q2.enqueue(1, 10, b"x").unwrap();
190 assert_eq!(q2.expire_due(10), 1);
191 assert_eq!(q2.state_of(1), Some(Delivery::Expired));
192 }
193}