aex 0.1.6

A web 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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use tokio::io::AsyncWriteExt;

use crate::{
    connection::context::{BoxWriter, LocalTypeMap},
    http::{
        meta::HttpMetadata,
        protocol::{header::HeaderKey, header::Headers, status::StatusCode, version::HttpVersion},
    },
};

fn build_status_line(status: StatusCode, version: HttpVersion) -> Vec<u8> {
    let prefix = match version {
        HttpVersion::Http10 => b"HTTP/1.0 ".to_vec(),
        HttpVersion::Http11 => b"HTTP/1.1 ".to_vec(),
        HttpVersion::Http20 => b"HTTP/2.0 ".to_vec(),
    };
    let status_str = status.to_str();
    let mut buf = prefix;
    buf.extend_from_slice((status as u16).to_string().as_bytes());
    buf.push(b' ');
    buf.extend_from_slice(status_str.as_bytes());
    buf
}

pub struct Response<'a> {
    pub writer: &'a mut Option<BoxWriter>,
    pub local: &'a mut LocalTypeMap,
}

impl<'a> Response<'a> {
    pub async fn send(
        &mut self,
        headers: &Headers,
        body: &[u8],
        status: StatusCode,
        version: HttpVersion,
    ) -> anyhow::Result<()> {
        let w = self
            .writer
            .as_deref_mut()
            .ok_or_else(|| anyhow::anyhow!("Writer not available"))?;

        // Optimized: pre-allocate buffer
        let mut buf = Vec::with_capacity(256);

        // Status line
        let status_line = build_status_line(status, version);
        buf.extend_from_slice(&status_line);
        buf.extend_from_slice(b"\r\n");

        // Headers
        for (k, v) in headers {
            buf.extend_from_slice(k.as_str().as_bytes());
            buf.extend_from_slice(b": ");
            buf.extend_from_slice(v.as_bytes());
            buf.extend_from_slice(b"\r\n");
        }

        buf.extend_from_slice(b"\r\n");
        buf.extend_from_slice(body);

        w.write_all(&buf).await?;
        w.flush().await?;

        Ok(())
    }

    pub fn set_header(&mut self, key: impl Into<HeaderKey>, value: impl Into<String>) -> &mut Self {
        if let Some(meta) = self.local.get_mut::<HttpMetadata>() {
            meta.headers.insert(key.into(), value.into());
        }
        self
    }

    pub async fn send_response(&mut self) -> anyhow::Result<()> {
        let (headers, body, status, version) = {
            let meta = self
                .local
                .get_mut::<HttpMetadata>()
                .ok_or_else(|| anyhow::anyhow!("HttpMetadata not found"))?;
            meta.headers
                .insert(HeaderKey::ContentLength, meta.body.len().to_string());
            (
                meta.headers.clone(),
                meta.body.clone(),
                meta.status,
                meta.version,
            )
        };
        self.send(&headers, &body, status, version).await
    }

    pub async fn send_failure(&mut self) -> anyhow::Result<()> {
        let (headers, body, status, version) = {
            let meta = self
                .local
                .get_mut::<HttpMetadata>()
                .ok_or_else(|| anyhow::anyhow!("HttpMetadata not found"))?;
            if meta.status == StatusCode::Ok {
                meta.status = StatusCode::BadRequest;
            }
            if meta.body.is_empty() {
                meta.body = b"Error".to_vec();
            }
            meta.headers
                .insert(HeaderKey::ContentLength, meta.body.len().to_string());
            (
                meta.headers.clone(),
                meta.body.clone(),
                meta.status,
                meta.version,
            )
        };
        self.send(&headers, &body, status, version).await
    }
}