dope-manifold 0.22.0

Owned application and service composition for dope
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::marker::PhantomData;

use dope_core::{driver, driver::route::Identity};
use dope_net::link::{egress, pool::change};
use o3::base::time::Positive;
use session::{app, ingress::Source};

use crate::{
    app::{creation, env},
    client::{conn::engine::Startup, session, side, side::startup},
    service::{self, discover, health, sync},
};

pub(super) struct Seed<F, I, A, const N: usize> {
    pub(super) feedback: F,
    pub(super) snapshot: Option<service::Snapshot<service::Endpoint<I, A>, N>>,
}

/// Bound client construction settings retained through installation.
pub struct Config<'d, W> {
    caps: side::Capacities,
    backoff: health::Backoff,
    wire: W,
    egress: egress::Config,
    connection_lifetime: Option<Positive>,
    _domain: PhantomData<fn(&'d ()) -> &'d ()>,
}

impl<'d, W> Config<'d, W> {
    pub(super) const fn new(caps: side::Capacities, retry: health::Backoff, wire: W) -> Self {
        Self {
            caps,
            backoff: retry,
            wire,
            egress: egress::Config::DEFAULT,
            connection_lifetime: None,
            _domain: PhantomData,
        }
    }

    pub(super) const fn with_egress(mut self, config: egress::Config) -> Self {
        self.egress = config;
        self
    }

    pub(super) const fn with_ttl(mut self, ttl: Option<Positive>) -> Self {
        self.connection_lifetime = ttl;
        self
    }
}

impl<'d, W> Config<'d, W> {
    pub(super) fn build<
        'w,
        const MAX: usize,
        N,
        R,
        I,
        E,
        const ENDPOINTS: usize,
        F,
        X,
        S,
        ID: Identity + 'd,
        C,
        O,
    >(
        self,
        setup: session::Setup<'d, N, S>,
        seed: Seed<F, I, <<E as env::Spec>::Transport as dope_net::Transport>::Addr, ENDPOINTS>,
        aux: X,
        owner: &mut C,
        context: impl for<'a> Fn(&'a mut C) -> driver::Context<'a, 'd>,
        build: impl for<'q, 'h, 'p> FnOnce(
            super::Engine<'q, 'h, 'p, 'w, 'd, ID, N, R, I, E, ENDPOINTS, F, X>,
            &mut C,
        ) -> O,
    ) -> Result<O, creation::Error>
    where
        'd: 'w,
        N: session::Target<'d, ID, MAX>,
        S: Source<'d>,
        E: env::Spec,
        E::Wire: 'd,
        E::Transport: dope_net::Transport,
        I: Eq,
        R: sync::Policy,
        F: discover::Access,
        X: startup::Startup<'d, ID>,
        W: change::Prepare<'w, 'd, ID, E::Wire>,
    {
        let Self {
            caps,
            backoff: retry,
            wire,
            egress,
            connection_lifetime: ttl,
            _domain: _,
        } = self;
        let cap = caps.primary();
        let opts = <E::Transport as dope_net::Transport>::options(Default::default());
        let Seed { feedback, snapshot } = seed;
        service::Pool::try_with(cap, retry, opts, feedback, |mut ctl| {
            if let Some(set) = snapshot {
                ctl.try_sync(set, cap.into())
                    .map_err(creation::Error::Service)?;
            }
            let app = app::State::try_new(setup, cap, &mut context(owner))?;
            Startup {
                capacities: caps,
                egress,
                wire,
                connection_lifetime: ttl,
                app,
                ctl,
                aux,
                source: (),
            }
            .try_with(owner, context, build)
        })
        .map_err(creation::Error::Pool)?
    }
}