Skip to main content

qualia_core_db/net/peer/connectivity/
durable.rs

1//! Disconnection is a delivery mode. A relay write is never Delivered.
2
3#[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    /// Empty value.
27    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    /// Creates a default `DurableQueue`.
46    pub const fn new() -> Self {
47        Self {
48            jobs: [DurableJob::empty(); MAX_JOBS],
49            len: 0,
50        }
51    }
52
53    /// Enqueues `payload` for `op_id` expiring at `expiry_unix`; `Err(())` at capacity.
54    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    /// Relay socket write is not this transition.
78    pub fn mark_relay_write(&self) -> Delivery {
79        Delivery::QueuedLocally
80    }
81
82    /// `DurableQueue::advance`.
83    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    /// Drops jobs expiring at or before `now_unix`; returns count expired.
97    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    /// Delivery state for `op_id`.
114    pub fn state_of(&self, op_id: u64) -> Option<Delivery> {
115        self.find(op_id).map(|i| self.jobs[i].state)
116    }
117
118    /// Queued job count.
119    pub(crate) fn len(&self) -> usize {
120        self.len
121    }
122
123    /// Job at index `i`.
124    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    /// Restores a persisted `job` into the queue.
133    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}