Skip to main content

qualia_core_db/bundle/stream/runtime/owner/
close.rs

1//! Once-only actual control completion/charge release, shared by both owners.
2use super::super::state::RuntimeClosePhase;
3use super::TransferRuntime;
4use crate::net::{peer::runtime::ReservationHandle, qdnf::errors::QdnfError as E};
5impl TransferRuntime<'_> {
6    pub fn close(&mut self) -> Result<(), E> {
7        if self.closed {
8            return Err(E::DoubleRelease);
9        }
10        if self.live != 0
11            || self.pending_records != 0
12            || self.workspace_live != 0
13            || self.source_live != 0
14        {
15            return Err(E::WouldBlock);
16        }
17        if self.close_phase == RuntimeClosePhase::Open {
18            match self.operations.complete(
19                self.control_operation.id,
20                self.control_operation.generation,
21                self.leases,
22            ) {
23                Ok(()) | Err(E::Cancelled) => {}
24                Err(e) => return Err(e),
25            }
26            self.close_phase = RuntimeClosePhase::ControlReleased;
27        }
28        if self.close_phase == RuntimeClosePhase::ControlReleased {
29            let next = self
30                .used_bytes
31                .checked_sub(self.control_budget.bytes)
32                .ok_or(E::Conflict)?;
33            let handle = self.control_charge.take().ok_or(E::Incomplete)?;
34            let original = handle.as_ref();
35            if let Err(e) = self
36                .ledger
37                .release_checked_bytes(handle, self.control_budget.bytes)
38            {
39                self.control_charge = Some(ReservationHandle::from_ref(original));
40                return Err(e);
41            }
42            self.used_bytes = next;
43            self.close_phase = RuntimeClosePhase::ControlChargeReleased;
44        }
45        if self.close_phase == RuntimeClosePhase::ControlChargeReleased {
46            let next = self
47                .used_bytes
48                .checked_sub(self.static_charge_bytes)
49                .ok_or(E::Conflict)?;
50            if next != 0 {
51                return Err(E::Conflict);
52            }
53            let handle = self.static_charge.take().ok_or(E::Incomplete)?;
54            let original = handle.as_ref();
55            if let Err(e) = self
56                .ledger
57                .release_checked_bytes(handle, self.static_charge_bytes)
58            {
59                self.static_charge = Some(ReservationHandle::from_ref(original));
60                return Err(e);
61            }
62            self.used_bytes = next;
63            self.close_phase = RuntimeClosePhase::Closed;
64            self.closed = true;
65        }
66        Ok(())
67    }
68}