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