sark-h2 0.23.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

use decode::mode::Discard;
use sark_http::field::metadata::{
    lower,
    section::{rules, storage},
};

use crate::{
    conn::ingress::{Decode, header::sink, headers::Pending},
    hpack::decode::{self, limit::Budget, phase::Phase},
};

pub(super) struct Active<P: rules::Policy> {
    pub(super) pending: Pending,
    pub(super) source: Source<P>,
    pub(super) wire_len: usize,
}

pub(super) enum Source<P: rules::Policy> {
    Store {
        block: Phase<Decode>,
        budget: Budget,
        sink: sink::Header<P>,
    },
    Discard(Phase<Discard>, Budget, storage::Scratch),
}

impl<P: rules::Policy> Source<P> {
    fn decode<'a, A, I>(self, parts: I) -> Result<Self, decode::Failure<lower::Error>>
    where
        A: rules::Push,
        I: IntoIterator<Item = &'a [u8]>,
    {
        match self {
            Self::Store {
                block,
                mut budget,
                sink,
            } => match block.feed_all(&mut budget, parts, sink.hpack::<A>()) {
                Ok((block, sink)) => Ok(Self::Store {
                    block,
                    budget,
                    sink: sink.into_header(),
                }),
                Err((sink, cause)) => {
                    drop(sink.into_header().recycle());
                    Err(cause)
                }
            },
            Self::Discard(block, mut budget, scratch) => {
                match block.feed_all(&mut budget, parts, ()) {
                    Ok((block, ())) => Ok(Self::Discard(block, budget, scratch)),
                    Err(((), cause)) => {
                        drop(scratch);
                        Err(cause.into())
                    }
                }
            }
        }
    }
}

impl<P: rules::Policy> Active<P> {
    pub(super) fn decode<'a, A, I>(
        self,
        parts: I,
        wire_len: usize,
    ) -> Result<Self, decode::Failure<lower::Error>>
    where
        A: rules::Push,
        I: IntoIterator<Item = &'a [u8]>,
    {
        let pending = self.pending;
        let source = self.source.decode::<A, I>(parts)?;
        Ok(Self {
            pending,
            source,
            wire_len,
        })
    }
}