Skip to main content

qualia_core_db/bundle/stream/runtime/
transfer.rs

1//! Coupled admission and completion; only original parent tokens release budget.
2use super::types::{Slot, schedule_id};
3use super::{
4    CancelReason, ColdPlan, CompletionKey, FinishOutcome, RequestCredit, TransferRuntime,
5    TransferState, TransferTicket,
6};
7use crate::net::peer::runtime::{CancelEpoch, ResourceBudget, ScheduledWork};
8use crate::net::qdnf::{errors::QdnfError, types::Generation};
9
10impl TransferRuntime<'_> {
11    pub fn admit(
12        &mut self,
13        plan: &ColdPlan<'_>,
14        index: usize,
15        now: u64,
16        current_policy: Generation,
17    ) -> Result<TransferTicket, QdnfError> {
18        self.require_open()?;
19        let spec = plan.row(index)?;
20        let mut budget = spec.validate()?;
21        if now >= spec.deadline {
22            return Err(QdnfError::Expired);
23        }
24        if current_policy != spec.policy_generation {
25            return Err(QdnfError::Revoked);
26        }
27        if self.live >= self.supported_inflight() {
28            return Err(QdnfError::Capacity);
29        }
30        let slot = self
31            .slots
32            .iter()
33            .position(|s| s.state == TransferState::Vacant)
34            .ok_or(QdnfError::Capacity)?;
35        let generation = self.slots[slot].generation.next()?;
36        let metadata = core::mem::size_of::<TransferTicket>()
37            .checked_add(core::mem::size_of::<RequestCredit>())
38            .and_then(|n| n.checked_add(core::mem::size_of::<CompletionKey>()))
39            .ok_or(QdnfError::Range)?;
40        budget = budget.saturating_add(ResourceBudget {
41            bytes: u64::try_from(metadata).map_err(|_| QdnfError::Range)?,
42            work: 0,
43            io: 0,
44        })?;
45        let window = self
46            .used_bytes
47            .checked_add(budget.bytes)
48            .ok_or(QdnfError::Range)?;
49        if window > self.profile.window_bytes() {
50            return Err(QdnfError::BudgetExhausted);
51        }
52        let capacity = u32::try_from(budget.bytes).map_err(|_| QdnfError::Range)?;
53        let serial = self
54            .serial
55            .checked_add(1)
56            .ok_or(QdnfError::StaleGeneration)?;
57        let schedule = schedule_id(self.owner, serial)?;
58        if self.scheduler.contains_operation(schedule) {
59            return Err(QdnfError::Conflict);
60        }
61        let reservation =
62            self.governor
63                .admit_and_reserve(self.ledger, budget, spec.class, spec.verified_peer)?;
64        let lease = match self.leases.acquire(capacity, true) {
65            Ok(l) => l,
66            Err(e) => {
67                self.ledger.release(reservation)?;
68                return Err(e);
69            }
70        };
71        let operation = match self.operations.admit(spec.operation, lease.handle) {
72            Ok(h) => h,
73            Err(e) => {
74                let a = self.leases.release(lease.handle);
75                let b = self.ledger.release(reservation);
76                a?;
77                b?;
78                return Err(e);
79            }
80        };
81        let work = ScheduledWork {
82            operation: schedule,
83            scope: spec.principal,
84            class: spec.class,
85            cost: spec.cost,
86            deadline: spec.deadline,
87        };
88        if let Err(e) = self.scheduler.enqueue(work) {
89            let a = self
90                .operations
91                .complete(operation.id, operation.generation, self.leases);
92            let b = self.ledger.release(reservation);
93            a?;
94            b?;
95            return Err(e);
96        }
97        self.serial = serial;
98        self.used_bytes = window;
99        self.live += 1;
100        self.pending_records += 1;
101        self.slots[slot] = Slot {
102            generation,
103            state: TransferState::Queued,
104            operation: Some(operation),
105            work: Some(work),
106            queued: true,
107            reservation: Some(reservation),
108            budget,
109            deadline: spec.deadline,
110            policy: spec.policy_generation,
111            credit: spec.credit_bytes,
112            proof_bytes: spec.requirements.proof.bytes,
113            storage_bytes: spec.requirements.storage.bytes,
114            cancel_epoch: CancelEpoch::ZERO,
115        };
116        Ok(TransferTicket {
117            key: self.key(slot)?,
118            spent: false,
119        })
120    }
121
122    /// Caller asserts all actual I/O/borrowers have ended. Does not certify bytes or consumption.
123    pub fn complete_io(
124        &mut self,
125        ticket: &mut TransferTicket,
126        key: CompletionKey,
127        now: u64,
128    ) -> Result<FinishOutcome, QdnfError> {
129        let i = self.validate(ticket)?;
130        if key != ticket.key {
131            return Err(QdnfError::StaleGeneration);
132        }
133        if now >= self.slots[i].deadline {
134            self.cancel_slot(i, CancelReason::Expired)?;
135        }
136        if self.slots[i].queued {
137            return Err(QdnfError::WouldBlock);
138        }
139        let state = self.slots[i].state;
140        if !matches!(
141            state,
142            TransferState::InFlight | TransferState::Cancelling(_)
143        ) {
144            return Err(QdnfError::WouldBlock);
145        }
146        let operation = self.slots[i].operation.ok_or(QdnfError::Incomplete)?;
147        match self
148            .operations
149            .complete(operation.id, operation.generation, self.leases)
150        {
151            Ok(()) | Err(QdnfError::Cancelled) => {}
152            Err(e) => return Err(e),
153        }
154        let reservation = self.slots[i]
155            .reservation
156            .take()
157            .ok_or(QdnfError::Incomplete)?;
158        self.ledger.release(reservation)?;
159        self.used_bytes -= self.slots[i].budget.bytes;
160        self.live -= 1;
161        self.slots[i].clear();
162        ticket.spent = true;
163        Ok(match state {
164            TransferState::Cancelling(CancelReason::Cancelled) => FinishOutcome::Cancelled,
165            TransferState::Cancelling(CancelReason::Expired) => FinishOutcome::Expired,
166            TransferState::Cancelling(CancelReason::Revoked) => FinishOutcome::Revoked,
167            _ => FinishOutcome::Released,
168        })
169    }
170}