sark-h2 0.29.1

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

use std::{mem, num::NonZero};

use dope::{core::driver::route::Identity, manifold::network::listener::conn};
use o3::depot::{
    map::direct,
    queue::{indexed::slab, links},
};
use slab::phase;
use task::{
    Target,
    registry::{Record, Tag},
};

use crate::{server::task, stream};

type Slot<'a, 'd, ID, T, C = NonZero<u32>> =
    slab::Vacant<'a, Record<'d, ID, T>, Tag, { u32::MAX }, links::Hook, 0, C, phase::Vacant>;

/// Infallible commit capability after both task indices have been validated.
#[must_use = "a vacant H2 task admission is rolled back unless inserted"]
pub(in crate::server::task) struct Vacant<'a, 'd, ID: Identity, T> {
    task: Slot<'a, 'd, ID, T>,
    index: direct::Vacant<'a, stream::Key, slab::Handle<Tag>>,
    connection: conn::Id<'d, ID>,
}

impl<'a, 'd, ID: Identity + 'd, T> Vacant<'a, 'd, ID, T> {
    pub(in crate::server::task) fn new(
        task: Slot<'a, 'd, ID, T>,
        index: direct::Vacant<'a, stream::Key, slab::Handle<Tag>>,
        id: conn::Id<'d, ID>,
    ) -> Self {
        const {
            assert!(
                mem::size_of::<Slot<'a, 'd, ID, T>>()
                    == mem::size_of::<Slot<'a, 'd, ID, T, o3::depot::capacity::Count>>()
            );
        }
        Self {
            task,
            index,
            connection: id,
        }
    }

    pub(in crate::server::task) fn try_insert<E>(
        self,
        build: impl FnOnce(Target<'d, ID>) -> Result<T, E>,
    ) -> Result<(), E> {
        let Self {
            task,
            index,
            connection: id,
        } = self;
        let occupied = task.try_insert(|key| {
            let target = Target::new(key);
            build(target).map(|task| Record {
                connection: id,
                stream: index.key(),
                task,
                unreported: true,
            })
        })?;
        index.insert(occupied.key());
        Ok(())
    }
}