dope-runtime 0.40.0

Thread-per-core execution and process lifecycle for dope
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use dope_core::driver::storage;

use crate::{
    executor::{self, boot, session},
    topology::{self, app, lending},
};

/// Generative worker scope after storage construction and before application install.
pub struct Worker<'scope, 'life: 'scope, 'p: 'life, 'd: 'p, S: storage::Plan + 'd, I: 'd, Q: 'd> {
    pub(super) session: session::Scope<'scope, 'life, 'p, 'd, S, Q>,
    pub(super) installer: I,
}

impl<'scope, 'life: 'scope, 'p: 'life, 'd: 'p, S: storage::Plan + 'd, I: 'd, Q: 'd>
    Worker<'scope, 'life, 'p, 'd, S, I, Q>
{
    pub(crate) const fn new(
        session: session::Scope<'scope, 'life, 'p, 'd, S, Q>,
        setup: I,
    ) -> Self {
        Self {
            session,
            installer: setup,
        }
    }
}

impl<'scope, 'life: 'scope, 'p: 'life, 'd: 'p, S, I, Q> Worker<'scope, 'life, 'p, 'd, S, I, Q>
where
    S: storage::Plan + 'd,
    I: 'd,
    Q: executor::Startup + 'd,
{
    /// Borrows storage from the exact prepared domain.
    pub fn storage(&self) -> &'life S::Output<'p, 'd> {
        self.session.storage()
    }

    /// Consumes the retained specification in one lexical lending scope.
    pub fn lend<R>(
        mut self,
        compose: impl FnOnce(I, &mut lending::Stage<'_, 'scope, 'life, 'p, 'd, S, Q>) -> R,
    ) -> R {
        let mut stage = lending::Stage::new(&mut self.session);
        compose(self.installer, &mut stage)
    }

    /// Runs the retained installer and consumer inside their storage loans.
    pub fn with<N, R, E>(mut self, next: N) -> Result<R, E>
    where
        I: for<'stage> lending::Installer<
                lending::Stage<'stage, 'scope, 'life, 'p, 'd, S, Q>,
                N,
                Output = R,
                Error = E,
            >,
    {
        let mut stage = lending::Stage::new(&mut self.session);
        self.installer.install(&mut stage, next)
    }

    /// Drives a yielding installation before publishing the resulting application.
    /// Rejects existing native work and cancels the unpolled root on admission failure.
    pub fn install_with<A, R, E>(
        mut self,
        install: impl FnOnce(I, &topology::Boot<'_, 'scope, 'life, 'p, 'd, S, Q>) -> R,
    ) -> Result<app::Application<'scope, 'life, 'p, 'd, S, A, Q>, topology::InstallError<E>>
    where
        A: executor::raw::App<'d>,
        R: boot::Root<'d, Output = Result<A, E>>,
    {
        let root = {
            let stage = topology::Boot::new(&self.session);
            install(self.installer, &stage)
        };
        let app = self
            .session
            .drive(root)
            .map_err(topology::InstallError::Drive)?
            .map_err(topology::InstallError::Install)?;
        Ok(app::Application {
            session: self.session,
            app,
        })
    }
}

impl<'scope, 'life: 'scope, 'p: 'life, 'd: 'p, S, I, Q> Worker<'scope, 'life, 'p, 'd, S, I, Q>
where
    S: storage::Plan + 'd,
    I: topology::Installer<S> + 'd,
    Q: executor::Startup + 'd,
{
    pub fn install(
        mut self,
    ) -> Result<app::Application<'scope, 'life, 'p, 'd, S, I::App<'life, 'p, 'd>, Q>, I::Error>
    {
        let app = {
            let mut stage = topology::Stage::new(&mut self.session);
            self.installer.install(&mut stage)?
        };
        Ok(app::Application {
            session: self.session,
            app,
        })
    }
}