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

use std::marker;

use dope::core::random;
use o3::{
    alloc,
    buffer::{hold, pool, pool::owners},
    depot::capacity,
};
use sark_core::{
    life::session,
    manifold::{client::domain, schedule},
};
use sark_http::{field::metadata::section::rules, payload::compress::dynamic::hash};

use crate::{
    ClientRole, INGRESS_RETENTION,
    client::Domain,
    conn::{self, config, event, machine},
    stream::Key,
};

/// Validated storage and connection plan for one H2 client.
pub struct Plan<F = rules::RetainRaw> {
    config: config::Validated<ClientRole>,
    marker: marker::PhantomData<fn() -> F>,
}

impl<F> Copy for Plan<F> {}

impl<F> Clone for Plan<F> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<F> Plan<F> {
    pub fn new(slots: usize) -> Result<Self, config::Error> {
        let raw = config::Config {
            stream_capacity: slots,
            ..config::Config::default()
        };
        Ok(Self::from(config::Validated::new(raw)?))
    }

    /// Exact byte capacity admitted for this connection's input queue.
    #[doc(hidden)]
    pub const fn inbound_capacity(&self) -> usize {
        self.config.inbound_capacity()
    }
}

impl<F> From<config::Validated<ClientRole>> for Plan<F> {
    /// Retains an already validated connection configuration without checking it again.
    fn from(config: config::Validated<ClientRole>) -> Self {
        Self {
            config,
            marker: marker::PhantomData,
        }
    }
}

impl<F: rules::Policy, C: session::Storage> domain::Plan<C> for Plan<F> {
    type Key = Key;
    type Block = conn::DataBlock;
    type Permit = pool::Span<owners::Plain<pool::Width<1>>, pool::Owned, pool::Frozen>;
    type Fields = F::Block;
    type Selection = F::Selection;
    type Connection = machine::Connection<ClientRole, F, C>;
    type Domain<T> = Domain<T, F>;
    type Build = conn::Build;
    type Storage = alloc::Error;

    const RETENTION: hold::Policy = INGRESS_RETENTION;
    const MIN_PREFIX: usize = event::MIN_RETAINED_WRITE_PREFIX_CAPACITY;

    fn open(self) -> Result<Self::Connection, Self::Build> {
        machine::Connection::from_plan(self.config)
    }

    fn open_seeded(self, seed: &random::Seed) -> Result<Self::Connection, Self::Build> {
        machine::Connection::from_seed(self.config, hash::Seed::new(seed))
    }

    fn domain<T>(cap: capacity::Count) -> Result<Self::Domain<T>, Self::Storage> {
        Ok(Domain {
            inner: schedule::Runtime::try_bounded(cap, cap)?,
            marker: marker::PhantomData,
        })
    }
}

const _: () = assert!(!core::mem::needs_drop::<Plan>());
const _: () =
    assert!(core::mem::size_of::<Plan>() == core::mem::size_of::<config::Validated<ClientRole>>());