Skip to main content

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

1//! Exactly-once completion. Late cancel reclaim cannot publish verified bits.
2use super::super::{FinishOutcome, TransferRuntime, TransferState, TransferTicket};
3use super::ticket::{JobState, StorageJobTicket};
4use super::StorageJobs;
5use crate::net::qdnf::errors::QdnfError;
6
7impl StorageJobs {
8    /// True only while the original transfer is still InFlight and the job was
9    /// not cancelled or failed. Call after I/O, before [`Self::complete_io`].
10    pub fn may_publish_verified(
11        &self,
12        runtime: &TransferRuntime<'_>,
13        ticket: &TransferTicket,
14        job: &StorageJobTicket,
15    ) -> Result<bool, QdnfError> {
16        let i = self.validate(runtime, ticket, job)?;
17        if self.slot(i).state != JobState::Submitted {
18            return Ok(false);
19        }
20        Ok(runtime.state(ticket)? == TransferState::InFlight)
21    }
22
23    /// Worker error/panic: keep the original charge and buffer occupancy.
24    /// The slot is not vacant; [`Self::complete_io`] is still required.
25    pub fn observe_worker_failure(
26        &mut self,
27        runtime: &mut TransferRuntime<'_>,
28        ticket: &TransferTicket,
29        job: &StorageJobTicket,
30    ) -> Result<(), QdnfError> {
31        let i = self.validate(runtime, ticket, job)?;
32        runtime.cancel(ticket)?;
33        self.slot_mut(i).state = JobState::Failed;
34        Ok(())
35    }
36
37    /// Exactly-once parent complete plus job retirement. A second call refuses
38    /// without touching the original ledger again.
39    pub fn complete_io(
40        &mut self,
41        runtime: &mut TransferRuntime<'_>,
42        ticket: &mut TransferTicket,
43        job: &mut StorageJobTicket,
44        now: u64,
45    ) -> Result<FinishOutcome, QdnfError> {
46        let i = self.validate(runtime, ticket, job)?;
47        let key = job.key;
48        let outcome = runtime.complete_io(ticket, key, now)?;
49        self.retire_slot(i, job);
50        Ok(outcome)
51    }
52
53    /// Job-table half after a parent `complete_io` performed through another
54    /// access path (for example a short RuntimeParents scope). Does not refund.
55    pub fn take_completed(
56        &mut self,
57        ticket: &TransferTicket,
58        job: &mut StorageJobTicket,
59    ) -> Result<(), QdnfError> {
60        if !ticket.spent {
61            return Err(QdnfError::WouldBlock);
62        }
63        job.matches_transfer(ticket)?;
64        let i = self.validate_job_after_parent(job)?;
65        self.retire_slot(i, job);
66        Ok(())
67    }
68
69    fn validate_job_after_parent(&self, job: &StorageJobTicket) -> Result<usize, QdnfError> {
70        if job.spent {
71            return Err(QdnfError::DoubleRelease);
72        }
73        if job.key.owner != self.owner() {
74            return Err(QdnfError::StaleGeneration);
75        }
76        let i = usize::from(job.job_slot);
77        let slot = match self.slot_at(i) {
78            Some(slot) => slot,
79            None => return Err(QdnfError::StaleGeneration),
80        };
81        if slot.state == JobState::Vacant
82            || slot.generation != job.job_generation
83            || slot.key != job.key
84        {
85            return Err(QdnfError::StaleGeneration);
86        }
87        Ok(i)
88    }
89}