qualia_core_db/bundle/stream/runtime/state/
access.rs1use super::super::sparse_workspace::{SparsePageWorkspace, WorkspaceReleaseError};
3use super::super::{
4 CancelReason, ColdPlan, CompletionKey, FinishOutcome, RequestCredit, RuntimePoll, StorageStage,
5 TransferRuntime, TransferState, TransferTicket,
6};
7use crate::bundle::stream::storage::StorageIdentity;
8use crate::net::{
9 peer::runtime::{AdmissionScopes, CancelEpoch},
10 qdnf::{errors::QdnfError as E, types::Generation},
11};
12pub struct RuntimeAccess<'borrow, 'parents> {
13 runtime: &'borrow mut TransferRuntime<'parents>,
14 ledger_owner: &'borrow std::sync::Mutex<crate::net::peer::runtime::ReservationLedger>,
15 ledger_incarnation: crate::net::peer::runtime::incarnation::CanonicalIncarnation,
16}
17impl<'b, 'p> RuntimeAccess<'b, 'p> {
18 pub(super) fn new(
19 runtime: &'b mut TransferRuntime<'p>,
20 ledger_owner: &'b std::sync::Mutex<crate::net::peer::runtime::ReservationLedger>,
21 ledger_incarnation: crate::net::peer::runtime::incarnation::CanonicalIncarnation,
22 ) -> Self {
23 Self {
24 runtime,
25 ledger_owner,
26 ledger_incarnation,
27 }
28 }
29 pub fn verify_external_reservation(
31 &self,
32 owner: &std::sync::Mutex<crate::net::peer::runtime::ReservationLedger>,
33 incarnation: crate::net::peer::runtime::incarnation::CanonicalIncarnation,
34 handle: &crate::net::peer::runtime::ReservationHandle,
35 expected: crate::net::peer::runtime::ResourceBudget,
36 ) -> Result<(), E> {
37 if !core::ptr::eq(owner, self.ledger_owner)
38 || !incarnation.assigned()
39 || incarnation != self.ledger_incarnation
40 || self.runtime.ledger.existing_incarnation() != incarnation
41 {
42 return Err(E::StaleGeneration);
43 }
44 self.runtime.ledger.check_reservation(handle, expected)
45 }
46 pub fn admit(
47 &mut self,
48 plan: &ColdPlan<'_>,
49 index: usize,
50 now: u64,
51 policy: Generation,
52 ) -> Result<TransferTicket, E> {
53 self.runtime.admit(plan, index, now, policy)
54 }
55 pub fn poll(&mut self, now: u64) -> Result<RuntimePoll, E> {
56 self.runtime.poll(now)
57 }
58 pub fn issue_credit(
59 &mut self,
60 ticket: &TransferTicket,
61 now: u64,
62 policy: Generation,
63 ) -> Result<RequestCredit, E> {
64 self.runtime.issue_credit(ticket, now, policy)
65 }
66 pub fn state(&self, ticket: &TransferTicket) -> Result<TransferState, E> {
67 self.runtime.state(ticket)
68 }
69 pub fn cancel_epoch(&self, ticket: &TransferTicket) -> Result<CancelEpoch, E> {
70 self.runtime.cancel_epoch(ticket)
71 }
72 pub fn cancel(&mut self, ticket: &TransferTicket) -> Result<(), E> {
73 self.runtime.cancel(ticket)
74 }
75 pub fn expire(&mut self, now: u64) -> Result<usize, E> {
76 self.runtime.expire(now)
77 }
78 pub fn complete_io(
79 &mut self,
80 ticket: &mut TransferTicket,
81 key: CompletionKey,
82 now: u64,
83 ) -> Result<FinishOutcome, E> {
84 self.runtime.complete_io(ticket, key, now)
85 }
86 pub fn live_transfers(&self) -> usize {
87 self.runtime.live_transfers()
88 }
89 pub fn pending_schedule_records(&self) -> usize {
90 self.runtime.pending_schedule_records()
91 }
92 pub fn charged_window_bytes(&self) -> u64 {
93 self.runtime.charged_window_bytes()
94 }
95 pub fn supported_inflight(&self) -> usize {
96 self.runtime.supported_inflight()
97 }
98 pub fn parent_used(&self) -> AdmissionScopes {
99 self.runtime.parent_used()
100 }
101 pub fn acquire_sparse_page(
102 &mut self,
103 identity: StorageIdentity,
104 page: u64,
105 ) -> Result<SparsePageWorkspace, E> {
106 self.runtime.acquire_sparse_page(identity, page)
107 }
108 pub fn release_sparse_page(
109 &mut self,
110 page: SparsePageWorkspace,
111 ) -> Result<(), WorkspaceReleaseError> {
112 self.runtime.release_sparse_page(page)
113 }
114 pub fn storage_stage<'s>(
117 &'s mut self,
118 ticket: &'s TransferTicket,
119 payload: &'s [u8],
120 proof: &'s [u8],
121 scratch: &'s mut [u8],
122 now: u64,
123 policy: Generation,
124 ) -> Result<StorageStage<'s, 'p>, E> {
125 self.runtime
126 .storage_stage(ticket, payload, proof, scratch, now, policy)
127 }
128 #[cfg(not(target_arch = "wasm32"))]
129 pub fn release_recovery_source<'root>(
130 &mut self,
131 source: super::super::RetainedRecoverySource<'root>,
132 ) -> Result<(), super::super::SourceReleaseError<'root>> {
133 self.runtime.release_recovery_source(source)
134 }
135 pub(super) fn observe_cancellation(&mut self) -> Result<(), E> {
136 for index in 0..self.runtime.slots.len() {
138 let Some(op) = self.runtime.slots[index].operation else {
139 continue;
140 };
141 if self.runtime.operations.is_cancelled(op.id) {
142 self.runtime.cancel_slot(index, CancelReason::Cancelled)?;
143 }
144 }
145 Ok(())
146 }
147}