Skip to main content

qualia_core_db/bundle/stream/runtime/
dispatch.rs

1//! Fair readiness, one-shot capacity credit and retained-I/O cancellation.
2use super::{
3    CancelReason, RequestCredit, RuntimePoll, TransferRuntime, TransferState, TransferTicket,
4};
5use crate::net::peer::runtime::{CancelEpoch, PollOutcome};
6use crate::net::qdnf::{errors::QdnfError, types::Generation};
7
8impl TransferRuntime<'_> {
9    pub fn poll(&mut self, now: u64) -> Result<RuntimePoll, QdnfError> {
10        self.require_open()?;
11        let result = self.scheduler.poll(now)?;
12        let work = match result {
13            PollOutcome::Ready(w) | PollOutcome::Expired(w) => w,
14        };
15        // Only an exact still-queued record is ours. Unrelated records always return intact.
16        let Some(i) = self
17            .slots
18            .iter()
19            .position(|s| s.queued && s.work == Some(work))
20        else {
21            return Ok(RuntimePoll::External(result));
22        };
23        self.slots[i].queued = false;
24        self.pending_records -= 1;
25        if now >= self.slots[i].deadline {
26            self.cancel_slot(i, CancelReason::Expired)?;
27        }
28        if let TransferState::Cancelling(reason) = self.slots[i].state {
29            return Ok(RuntimePoll::Cancelled(self.key(i)?, reason));
30        }
31        self.slots[i].state = TransferState::Ready;
32        Ok(RuntimePoll::Ready(self.key(i)?))
33    }
34
35    pub fn issue_credit(
36        &mut self,
37        ticket: &TransferTicket,
38        now: u64,
39        current_policy: Generation,
40    ) -> Result<RequestCredit, QdnfError> {
41        let i = self.validate(ticket)?;
42        if now >= self.slots[i].deadline {
43            self.cancel_slot(i, CancelReason::Expired)?;
44        }
45        if current_policy != self.slots[i].policy {
46            self.cancel_slot(i, CancelReason::Revoked)?;
47        }
48        if let TransferState::Cancelling(reason) = self.slots[i].state {
49            return Err(reason.error());
50        }
51        if self.slots[i].state == TransferState::InFlight {
52            return Err(QdnfError::Replay);
53        }
54        if self.slots[i].state != TransferState::Ready {
55            return Err(QdnfError::WouldBlock);
56        }
57        self.slots[i].state = TransferState::InFlight;
58        Ok(RequestCredit {
59            key: ticket.key,
60            bytes: self.slots[i].credit,
61            cancel_epoch: self.slots[i].cancel_epoch,
62        })
63    }
64    pub fn state(&self, ticket: &TransferTicket) -> Result<TransferState, QdnfError> {
65        Ok(self.slots[self.validate(ticket)?].state)
66    }
67    pub fn cancel_epoch(&self, ticket: &TransferTicket) -> Result<CancelEpoch, QdnfError> {
68        Ok(self.slots[self.validate(ticket)?].cancel_epoch)
69    }
70    pub fn cancel(&mut self, ticket: &TransferTicket) -> Result<(), QdnfError> {
71        let i = self.validate(ticket)?;
72        self.cancel_slot(i, CancelReason::Cancelled)
73    }
74    pub fn expire(&mut self, now: u64) -> Result<usize, QdnfError> {
75        self.require_open()?;
76        let mut expired = 0;
77        for i in 0..self.slots.len() {
78            if matches!(
79                self.slots[i].state,
80                TransferState::Queued | TransferState::Ready | TransferState::InFlight
81            ) && now >= self.slots[i].deadline
82            {
83                self.cancel_slot(i, CancelReason::Expired)?;
84                expired += 1;
85            }
86        }
87        Ok(expired)
88    }
89    pub(super) fn cancel_slot(&mut self, i: usize, reason: CancelReason) -> Result<(), QdnfError> {
90        if matches!(self.slots[i].state, TransferState::Cancelling(_)) {
91            return Ok(());
92        }
93        let op = self.slots[i].operation.ok_or(QdnfError::Closed)?;
94        let epoch = self.operations.cancel(op.id)?;
95        self.slots[i].cancel_epoch = epoch;
96        self.slots[i].state = TransferState::Cancelling(reason);
97        Ok(())
98    }
99}