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

use o3::buffer::{hold, resident, storage};
use sark_core::life::{self, exchange};
use sark_http::owner::evidence::Sink as _;
use sark_http::{
    owner::{evidence, handoff},
    payload::owned,
};

use crate::{
    conn,
    server::{response::Pending, state::Transitions},
    stream,
};

#[doc(hidden)]
pub struct Receipt<'d> {
    pending: Option<Pending<'d>>,
    linked: hold::Charge,
    copied: Option<evidence::Copy>,
}

impl<'d> Receipt<'d> {
    pub(super) fn from_ready(
        body: handoff::Ready<'d>,
        linked: hold::Charge,
    ) -> Result<Self, conn::Error> {
        let (pending, copied) = match body {
            handoff::Ready::Empty => (None, None),
            handoff::Ready::Owned(mut body) => {
                let body = storage::Shared::try_from(&mut body)
                    .map_err(storage::AllocError::Exhausted)
                    .map_err(owned::Error::Storage)
                    .map_err(conn::Error::Response)?;
                (Pending::single(resident::Shared::from(body)), None)
            }
            handoff::Ready::Copied(body) => {
                let (body, copy) = body.into_parts();
                (Pending::single(resident::Shared::from(body)), Some(copy))
            }
            handoff::Ready::Retained(body) => (Pending::single(resident::Shared::from(body)), None),
            handoff::Ready::Segmented(body) | handoff::Ready::Linked(body) => {
                (Pending::new(body), None)
            }
            handoff::Ready::Fixed(body) => {
                let body: resident::Shared<'d> = resident::Shared::from(body.as_slice());
                (Pending::single(body), None)
            }
        };
        Ok(Self::new(pending, linked, copied))
    }

    pub(super) const fn new(
        pending: Option<Pending<'d>>,
        linked: hold::Charge,
        copied: Option<evidence::Copy>,
    ) -> Self {
        Self {
            pending,
            linked,
            copied,
        }
    }

    pub(super) fn empty() -> Self {
        Self::new(None, hold::Charge::default(), None)
    }

    pub(in crate::server) fn into_pending(self) -> Option<Pending<'d>> {
        self.pending
    }

    pub(in crate::server) fn observe<C: Copy, M: Transitions<C>>(
        self,
        mode: &mut M,
        exchange: exchange::Id<C, stream::Key>,
    ) -> Option<Pending<'d>> {
        if let Some(copied) = self.copied {
            life::response::Sink::new(mode, exchange).copied(copied);
        }
        if M::ENABLED || M::EXCHANGE_DEADLINES {
            let charge = if M::ENABLED {
                self.pending
                    .as_ref()
                    .map_or(hold::Charge::default(), Pending::retention)
            } else {
                hold::Charge::default()
            };
            mode.observe(life::Event::ResponseCommitted {
                exchange,
                body_bytes: charge.logical_bytes,
                charge,
                linked: self.linked,
            });
        }
        self.pending
    }
}