wmhttp 0.3.1

a http server for rust
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

// Copyright 2022 - 2023 Wenmeng See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// Author: tickbh
// -----
// Created Date: 2023/10/07 09:41:02

use std::task::Context;

use algorithm::buf::{Binary, BinaryMut, Bt};
use webparse::http::http2::frame::{
    Data, Flag, Frame, FrameHeader, Headers, Kind, StreamIdentifier,
};
use webparse::HeaderMap;

use crate::RecvRequest;

#[derive(Debug)]
pub struct SendRequest {
    pub stream_id: StreamIdentifier,
    pub request: RecvRequest,
    pub encode_header: bool,
    pub encode_body: bool,
    pub is_end_stream: bool,
}

impl SendRequest {
    pub fn new(stream_id: StreamIdentifier, request: RecvRequest, is_end_stream: bool) -> Self {
        SendRequest {
            stream_id,
            request,
            encode_header: false,
            encode_body: false,
            is_end_stream,
        }
    }

    pub fn encode_headers(request: &RecvRequest) -> HeaderMap {
        let mut headers = HeaderMap::new();
        headers.insert(":method", request.method().as_str().to_string());
        headers.insert(":path", request.path().clone());
        let scheme = request.scheme().as_str().to_string();
        let authority = request.get_connect_url().unwrap_or(String::new());
        if !scheme.is_empty() {
            headers.insert(":scheme", scheme);
        }
        if !authority.is_empty() {
            headers.insert(":authority", authority);
        }
        for h in request.headers().iter() {
            if h.0 != "Host" {
                headers.insert(h.0.clone(), h.1.clone());
            }
        }
        headers
    }

    pub fn encode_frames(&mut self, cx: &mut Context) -> (bool, Vec<Frame<Binary>>) {
        let mut result = vec![];
        if !self.encode_header {
            let mut header = FrameHeader::new(Kind::Headers, Flag::end_headers(), self.stream_id);
            if self.request.method().is_nobody() {
                header.flag.set(Flag::end_stream(), true);
            }
            let fields = Self::encode_headers(&self.request);
            let mut header = Headers::new(header, fields);
            header.set_method(self.request.method().clone());
            result.push(Frame::Headers(header));
            self.encode_header = true;
        }

        if !self.request.body().is_end() || !self.encode_body {
            self.encode_body = true;
            let mut binary = BinaryMut::new();
            let _ = self.request.body_mut().poll_encode_write(cx, &mut binary);
            if binary.remaining() > 0 {
                self.is_end_stream = self.request.body().is_end();
                let flag = if self.is_end_stream {
                    Flag::end_stream()
                } else {
                    Flag::zero()
                };
                let header = FrameHeader::new(Kind::Data, flag, self.stream_id);
                let data = Data::new(header, binary.freeze());
                result.push(Frame::Data(data));
            }
        }

        (self.is_end_stream, result)
    }
}