sark-h2 0.24.0

Fiber-free HTTP/2 protocol primitives and manifold server for sark
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

use dope::{
    core::{
        self,
        driver::{
            route::Identity,
            settings,
            settings::{claim, errors},
            storage,
        },
    },
    manifold::{
        self,
        app::{self, env},
        network::listener,
        timing,
    },
    net::{
        tcp,
        wire::{self, domain},
    },
    runtime::{
        executor,
        topology::{lending, recipe},
    },
};

use crate::server::runtime::{Plan, modes};

/// Owns the H2 plan and service recipe until their storage is borrowed.
pub struct Recipe<ID: Identity, F> {
    plan: Plan<ID>,
    recipe: F,
}

impl<ID: Identity, F> Recipe<ID, F> {
    pub(in crate::server::runtime) const fn new(plan: Plan<ID>, recipe: F) -> Self {
        Self { plan, recipe }
    }
}

impl<ID: Identity, F> settings::Resource for Recipe<ID, F> {
    fn include_in(&self, needs: claim::Needs) -> Result<claim::Needs, errors::Claim> {
        self.plan.include_in(needs)
    }
}

impl<'stage, 'scope, 'life: 'scope, 'e: 'life, 'd: 'e, S, Q, N, O, ID: Identity + 'd, F>
    lending::Installer<lending::Stage<'stage, 'scope, 'life, 'e, 'd, S, Q>, N> for Recipe<ID, F>
where
    S: storage::Plan + 'd,
    Q: executor::Startup,
    F: modes::Family<S, ID> + 'd,
    N: for<'g, 'n, 'p, 's> lending::Next<
            lending::Stage<'stage, 'scope, 'life, 'e, 'd, S, Q>,
            app::Host<
                listener::Listener<
                    'n,
                    'p,
                    's,
                    'd,
                    'd,
                    ID,
                    F::Application<'g, 'life, 'e, 'd>,
                    env::Bundle<tcp::Tcp, wire::Identity, timing::Throughput>,
                >,
            >,
            Output = O,
        >,
{
    type Output = O;
    type Error = manifold::BuildError<core::BranchError<F::Error, F::Failure>>;

    fn install(
        self,
        stage: &mut lending::Stage<'stage, 'scope, 'life, 'e, 'd, S, Q>,
        next: N,
    ) -> Result<O, Self::Error> {
        let service = recipe::Build::build(self.recipe, stage.storage())
            .map_err(core::BranchError::First)
            .map_err(manifold::BuildError::Factory)?;
        let (config, conn, bound, lifetime) = self.plan.into_parts();
        let install = listener::Install::<
            ID,
            env::Bundle<tcp::Tcp, wire::Identity, timing::Throughput>,
            _,
        >::new(config, domain::Local::new(wire::Identity))
        .with_bound(bound);
        let install = match lifetime {
            Some(lifetime) => install.with_life(lifetime),
            None => install,
        };
        let binding = install.binding(stage.driver().driver_ref());
        <F as modes::Family<S, ID>>::with(service, conn, binding, |app| {
            install
                .in_stage(stage, app, |listener, stage| {
                    next.run(app::Host::new(listener), stage)
                })
                .map_err(manifold::BuildError::Create)
        })
        .map_err(core::BranchError::Second)
        .map_err(manifold::BuildError::Factory)?
    }
}