sark-h2 0.29.3

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

use std::marker;

use sark_core::manifold::{
    schedule,
    server::app::{self, Capacity, Spec},
};
use sark_http::payload::compress::dynamic::hash;

use crate::{
    conn::{config, event, ingress::PrefacePhase, machine},
    server::runtime::{
        self, Connection,
        output::{self, flush::End},
    },
};

pub struct State<'d, A, O>
where
    A: app::Application<'d, Connection<'d, A>, O>,
{
    pub(in crate::server::runtime) carrier: Connection<'d, A>,
    pub(in crate::server::runtime) app: A::State,
    owner: marker::PhantomData<fn(O) -> O>,
}

impl<'d, A, O> State<'d, A, O>
where
    A: app::Application<'d, Connection<'d, A>, O>,
{
    pub(super) fn try_new(
        app: &A,
        machine: &config::Validated<crate::ServerRole>,
        seed: hash::Seed,
        preface: PrefacePhase,
    ) -> Result<Self, runtime::Build<A::Build>> {
        let carrier = Connection::<'d, A>::from_runtime_seed(machine, seed, preface)
            .map_err(runtime::Build::Connection)?;
        let capacity = Capacity::new(machine.stream_count(), machine.data_events().raw());
        let app = app.state(capacity).map_err(runtime::Build::App)?;
        Ok(Self {
            carrier,
            app,
            owner: marker::PhantomData,
        })
    }

    fn activity(&self) -> schedule::Quiescence {
        match (A::activity(&self.app), self.carrier.status().active_len()) {
            (schedule::Quiescence::Quiet, 0) => schedule::Quiescence::Quiet,
            (schedule::Quiescence::Busy | schedule::Quiescence::Quiet, _) => {
                schedule::Quiescence::Busy
            }
        }
    }

    pub(super) fn begin_drain(&mut self) {
        let activity = self.activity();
        self.carrier.control().drain(activity);
    }
}

impl<'d, A, O> output::State<'d> for State<'d, A, O>
where
    A: app::Application<'d, Connection<'d, A>, O>,
{
    type Fields = <A as Spec>::Fields;
    type Evidence = event::Ignore;

    fn protocol(&mut self) -> &mut Connection<'d, A> {
        &mut self.carrier
    }

    fn settle(&mut self) -> End {
        use machine::ops::Drain;

        if self.carrier.status().is_closing() {
            return End::Close;
        }
        if !self.carrier.status().is_goaway() {
            return End::Keep;
        }
        let activity = self.activity();
        match self.carrier.control().finish(activity) {
            Drain::Complete => End::Close,
            Drain::Pending => End::Keep,
        }
    }
}