Skip to main content

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

1//! Consuming retained-owner close; partial progress is restored for retry.
2use super::RetainedRuntime;
3use crate::net::qdnf::errors::QdnfError as E;
4use core::sync::atomic::Ordering;
5#[must_use]
6pub struct RuntimeCloseError<'parent, 'host> {
7    pub error: E,
8    pub state: RetainedRuntime<'parent, 'host>,
9}
10impl core::fmt::Debug for RuntimeCloseError<'_, '_> {
11    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
12        f.debug_struct("RuntimeCloseError")
13            .field("error", &self.error)
14            .finish_non_exhaustive()
15    }
16}
17impl<'parent, 'host> RetainedRuntime<'parent, 'host> {
18    pub fn try_close(mut self) -> Result<(), RuntimeCloseError<'parent, 'host>> {
19        let parents = self.parents;
20        if let Err(error) = parents.association(&self) {
21            return Err(RuntimeCloseError { error, state: self });
22        }
23        let data = self
24            .data
25            .as_ref()
26            .expect("private retained state invariant");
27        let owner = data.owner;
28        let already_closed = data.closed;
29        if !already_closed {
30            if let Err(error) = parents.with_runtime_raw(&mut self, |runtime| runtime.close()) {
31                return Err(RuntimeCloseError { error, state: self });
32            }
33        }
34        if parents
35            .active
36            .compare_exchange(owner, 0, Ordering::AcqRel, Ordering::Acquire)
37            .is_err()
38        {
39            return Err(RuntimeCloseError {
40                error: E::Conflict,
41                state: self,
42            });
43        }
44        Ok(())
45    }
46}