qualia_core_db/bundle/stream/runtime/owner/
close.rs1use 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}