sark 0.12.0

Simple Asynchronous Rust webKit - Server
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#![allow(clippy::too_many_arguments)]

use std::ops::Range;

use sark_core::error::Result;
use sark_core::http::codec::BodyFraming;
use sark_core::http::head::Flags;

use super::plan::HeaderValue;
use super::spec::RouteParams;
use crate::dispatch::BodySource;
use crate::request;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BodyPolicy {
    Buffered,
    Discarded,
}

mod body_mode {
    use super::BodyPolicy;
    use crate::dispatch::BodySource;

    pub trait Sealed {
        const POLICY: BodyPolicy;

        fn bytes<B: BodySource>(body: &mut B) -> &[u8];
    }

    pub enum Buffered {}

    impl Sealed for Buffered {
        const POLICY: BodyPolicy = BodyPolicy::Buffered;

        fn bytes<B: BodySource>(body: &mut B) -> &[u8] {
            body.contiguous()
        }
    }

    pub enum Discarded {}

    impl Sealed for Discarded {
        const POLICY: BodyPolicy = BodyPolicy::Discarded;

        fn bytes<B: BodySource>(_body: &mut B) -> &[u8] {
            &[]
        }
    }
}

pub trait BodyMode: body_mode::Sealed {
    const POLICY: BodyPolicy = <Self as body_mode::Sealed>::POLICY;

    fn bytes<B: BodySource>(body: &mut B) -> &[u8] {
        <Self as body_mode::Sealed>::bytes(body)
    }
}

impl BodyMode for body_mode::Buffered {}
impl BodyMode for body_mode::Discarded {}

pub use body_mode::{Buffered, Discarded};

pub enum HeaderParse<H> {
    NeedMore,
    Bad,
    Ready {
        headers: H,
        head_len: usize,
        body_framing: BodyFraming,
        flags: Flags,
        accept_gzip: bool,
    },
}

pub trait RouteRequestImpl {
    type HeaderSlot: Copy;
    type RawHeaders: Default;
    type RawParams: Default;
    type Params<'req>: RouteParams<'req, Raw = Self::RawParams>;
    type Headers<'req>;
    type ParsedBody<'req>;
    type BodyMode: BodyMode;

    const FULL: bool = false;
    const BODY_POLICY: BodyPolicy = <Self::BodyMode as BodyMode>::POLICY;

    fn parse_body<'req>(raw: &'req [u8]) -> Result<Self::ParsedBody<'req>>;

    fn header_slot_bytes(_name: &[u8]) -> Option<Self::HeaderSlot> {
        None
    }

    fn parse_headers<const PARSE_ACCEPT_ENCODING: bool>(
        req_bytes: &[u8],
        headers_start: usize,
        max_header_count: usize,
    ) -> HeaderParse<Self::RawHeaders>;

    fn set_header_raw<V: HeaderValue>(
        _headers: &mut Self::RawHeaders,
        _slot: Self::HeaderSlot,
        _value: &V,
    ) -> Result<()> {
        Ok(())
    }

    fn set_query_name_raw<V: HeaderValue>(
        _headers: &mut Self::RawHeaders,
        _name: &[u8],
        _value: &V,
    ) -> Result<()> {
        Ok(())
    }

    fn set_query_slice_raw(
        _headers: &mut Self::RawHeaders,
        _name: &[u8],
        _input: &[u8],
        _range: Range<usize>,
    ) -> Result<()> {
        Ok(())
    }

    fn parse_query_raw(
        _headers: &mut Self::RawHeaders,
        _input: &[u8],
        _range: Range<usize>,
    ) -> Result<()> {
        Ok(())
    }

    fn build_headers<'req>(
        req: &request::Ref<'req>,
        headers: Self::RawHeaders,
    ) -> Result<Self::Headers<'req>>;

    fn build_params<'req>(
        req: &request::Ref<'req>,
        params: Self::RawParams,
    ) -> Option<Self::Params<'req>>
    where
        Self::Params<'req>: RouteParams<'req>,
    {
        <Self::Params<'req> as RouteParams<'req>>::from_raw(req, params)
    }
}