Skip to main content

qualia_core_db/bundle/stream/runtime/jobs/
submit.rs

1//! Short StorageStage recheck, then drop that borrow before blocking I/O.
2use super::super::{StorageStage, TransferRuntime, TransferTicket};
3use super::ticket::{JobSlot, JobState, StorageJobTicket, MAX_STORAGE_JOBS};
4use crate::net::qdnf::{errors::QdnfError, types::Generation};
5
6/// Occupancy for submitted storage work. Charges stay on the original transfer.
7pub struct StorageJobs {
8    owner: usize,
9    slots: [JobSlot; MAX_STORAGE_JOBS],
10    live: usize,
11}
12
13impl StorageJobs {
14    pub fn for_owner(owner: usize) -> Self {
15        Self {
16            owner,
17            slots: [JobSlot::empty(); MAX_STORAGE_JOBS],
18            live: 0,
19        }
20    }
21    pub fn for_runtime(runtime: &TransferRuntime<'_>) -> Self {
22        Self::for_owner(runtime.owner)
23    }
24    pub const fn live_jobs(&self) -> usize {
25        self.live
26    }
27    pub const fn owner(&self) -> usize {
28        self.owner
29    }
30    pub fn reserved_bytes(&self) -> u64 {
31        self.slots
32            .iter()
33            .filter(|s| s.state != JobState::Vacant)
34            .map(|s| s.reserved_bytes)
35            .fold(0, |a, b| a.saturating_add(b))
36    }
37    pub fn buffer_held(&self, job: &StorageJobTicket) -> Result<bool, QdnfError> {
38        if job.spent {
39            return Ok(false);
40        }
41        let i = usize::from(job.job_slot);
42        let slot = self.slots.get(i).ok_or(QdnfError::StaleGeneration)?;
43        Ok(slot.state != JobState::Vacant && slot.generation == job.job_generation)
44    }
45
46    /// Recheck the live stage, retain already-charged buffer occupancy, drop
47    /// the stage before returning. No second ReservationLedger is created.
48    pub fn submit(
49        &mut self,
50        runtime: &mut TransferRuntime<'_>,
51        ticket: &TransferTicket,
52        payload: &[u8],
53        proof: &[u8],
54        scratch: &mut [u8],
55        now: u64,
56        policy: Generation,
57    ) -> Result<StorageJobTicket, QdnfError> {
58        let stage = runtime.storage_stage(ticket, payload, proof, scratch, now, policy)?;
59        self.submit_stage(ticket, stage, now, policy)
60    }
61
62    /// Same occupancy rules when the caller already holds a short stage.
63    /// The stage value is dropped before this returns.
64    pub fn submit_stage(
65        &mut self,
66        ticket: &TransferTicket,
67        mut stage: StorageStage<'_, '_>,
68        now: u64,
69        policy: Generation,
70    ) -> Result<StorageJobTicket, QdnfError> {
71        if self.owner != ticket.completion_key().owner {
72            return Err(QdnfError::StaleGeneration);
73        }
74        if self.live >= MAX_STORAGE_JOBS {
75            return Err(QdnfError::Capacity);
76        }
77        let key = ticket.completion_key();
78        if self
79            .slots
80            .iter()
81            .any(|s| s.state != JobState::Vacant && s.key == key)
82        {
83            return Err(QdnfError::Replay);
84        }
85        let reserved =
86            stage.with_buffers(now, policy, |_, buffers| -> Result<u64, QdnfError> {
87                if buffers.scratch.len() >= buffers.payload.len() {
88                    buffers.scratch[..buffers.payload.len()].copy_from_slice(buffers.payload);
89                }
90                reserved_bytes(
91                    buffers.payload.len(),
92                    buffers.proof.len(),
93                    buffers.scratch.len(),
94                )
95            })??;
96        drop(stage);
97        let slot = self
98            .slots
99            .iter()
100            .position(|s| s.state == JobState::Vacant)
101            .ok_or(QdnfError::Capacity)?;
102        let generation = self.slots[slot].generation.next()?;
103        self.slots[slot] = JobSlot {
104            generation,
105            state: JobState::Submitted,
106            key,
107            reserved_bytes: reserved,
108        };
109        self.live += 1;
110        Ok(StorageJobTicket {
111            key,
112            job_generation: generation,
113            job_slot: slot as u8,
114            reserved_bytes: reserved,
115            spent: false,
116        })
117    }
118
119    /// Marks Cancelling on the job and the original transfer. The worker still
120    /// owns the already-charged buffers until [`StorageJobs::complete_io`].
121    pub fn cancel(
122        &mut self,
123        runtime: &mut TransferRuntime<'_>,
124        ticket: &TransferTicket,
125        job: &StorageJobTicket,
126    ) -> Result<(), QdnfError> {
127        let i = self.validate(runtime, ticket, job)?;
128        runtime.cancel(ticket)?;
129        self.slots[i].state = JobState::Cancelling;
130        Ok(())
131    }
132
133    pub(super) fn validate(
134        &self,
135        runtime: &TransferRuntime<'_>,
136        ticket: &TransferTicket,
137        job: &StorageJobTicket,
138    ) -> Result<usize, QdnfError> {
139        runtime.validate(ticket)?;
140        self.validate_job(ticket, job)
141    }
142
143    pub(super) fn validate_job(
144        &self,
145        ticket: &TransferTicket,
146        job: &StorageJobTicket,
147    ) -> Result<usize, QdnfError> {
148        job.matches_transfer(ticket)?;
149        if job.key.owner != self.owner {
150            return Err(QdnfError::StaleGeneration);
151        }
152        let i = usize::from(job.job_slot);
153        let slot = self.slots.get(i).ok_or(QdnfError::StaleGeneration)?;
154        if slot.state == JobState::Vacant
155            || slot.generation != job.job_generation
156            || slot.key != job.key
157        {
158            return Err(QdnfError::StaleGeneration);
159        }
160        Ok(i)
161    }
162
163    pub(super) fn slot_mut(&mut self, i: usize) -> &mut JobSlot {
164        &mut self.slots[i]
165    }
166    pub(super) fn slot(&self, i: usize) -> &JobSlot {
167        &self.slots[i]
168    }
169    pub(super) fn slot_at(&self, i: usize) -> Option<&JobSlot> {
170        self.slots.get(i)
171    }
172    pub(super) fn retire_slot(&mut self, i: usize, job: &mut StorageJobTicket) {
173        self.slots[i].clear();
174        self.live -= 1;
175        job.spent = true;
176    }
177}
178
179fn reserved_bytes(payload: usize, proof: usize, scratch: usize) -> Result<u64, QdnfError> {
180    let payload = u64::try_from(payload).map_err(|_| QdnfError::Range)?;
181    let proof = u64::try_from(proof).map_err(|_| QdnfError::Range)?;
182    let scratch = u64::try_from(scratch).map_err(|_| QdnfError::Range)?;
183    payload
184        .checked_add(proof)
185        .and_then(|n| n.checked_add(scratch))
186        .ok_or(QdnfError::Capacity)
187}