qualia_core_db/bundle/stream/runtime/
dispatch.rs1use 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 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}