qualia_core_db/bundle/stream/runtime/jobs/
submit.rs1use super::super::{StorageStage, TransferRuntime, TransferTicket};
3use super::ticket::{JobSlot, JobState, StorageJobTicket, MAX_STORAGE_JOBS};
4use crate::net::qdnf::{errors::QdnfError, types::Generation};
5
6pub 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 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 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 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}