Skip to main content

qualia_core_db/bundle/stream/runtime/state/
access.rs

1//! Narrow forwarding view; no DerefMut/raw runtime/parent owner escape.
2use 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    /// Same actual held ledger: validation only, never permission/new charge.
30    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    /// Bounded memory/proof checks ONLY in this short scope. Do not call actual
115    /// synchronous native read/write/flush here. Storage job handoff is separate.
116    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        // Reuse the actual canonical cancellation transition; no copied kernel.
137        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}