sark-h2 0.29.5

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
89
90
91
92
93
94
95

use o3::buffer::resident;
use sark_core::{
    decode::{self, request},
    manifold::schedule::{self, typed},
};
use sark_http::field::metadata::section::rules;

use crate::{
    conn::{self, event, machine},
    server,
    server::{
        response,
        state::exchange::Deferred,
        sync::book::{self, Book, Delayed, Receiving, driver, phase::Phase},
    },
    stream,
};

impl<'d, R> Book<'d, R>
where
    R: decode::Decode,
    R::Prepared: request::Synchronous,
{
    pub(in crate::server::sync) fn pump<'a, const ROUND: bool, B, P, D>(
        &'a mut self,
        conn: &'a mut machine::Connection<
            crate::ServerRole,
            R::Plan,
            resident::Shared<'d>,
            rules::RejectPush,
            event::Ignore,
        >,
        router: &'a R,
        limits: server::Config,
        egress: schedule::Egress,
        permit: B,
        report: D,
    ) -> schedule::Report
    where
        'd: 'a,
        B: FnMut() -> Option<P>,
        D: FnMut(conn::Error),
        driver::Driver<'a, 'd, R, B, D>: typed::Driver<
                Phase<'d, R>,
                response::Pending<'d>,
                Receiving<'d, R>,
                Key = stream::Key,
                Block = conn::DataBlock,
            >,
    {
        self.runtime.resume(|| conn.flow().poll_wake(), egress);
        let driver = &mut driver::Driver {
            connection: conn,
            router,
            limits,
            credit: &mut self.credit,
            permit,
            report,
        };
        match ROUND {
            true => self.runtime.drive_round(driver),
            false => self.runtime.drive(driver),
        }
    }

    pub(in crate::server::sync) fn clear(
        &mut self,
        conn: &mut machine::Connection<
            crate::ServerRole,
            R::Plan,
            resident::Shared<'d>,
            rules::RejectPush,
            event::Ignore,
        >,
    ) where
        Delayed<'d, R>: Deferred<'d, R::Prepared, R::Routes>,
    {
        if !self.runtime.is_empty() {
            for index in 0..self.runtime.capacity() {
                let Some(stream) = self.runtime.key_at(index) else {
                    continue;
                };
                if let Some(phase) = self.runtime.remove(stream) {
                    // SAFETY: this phase was removed from this account's own runtime.
                    match unsafe { book::raw::try_close(phase, &mut self.credit) } {
                        Ok(Some(head)) => head.discard(conn),
                        Ok(None) => {}
                        Err(error) => conn.streams().cancel(stream, error.code()),
                    }
                }
            }
        }
        self.runtime.clear();
    }
}