amoeba 0.1.0

A lightweight HTTP API library 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
117
118
119
120
121
122
123
124
125
126

use crate::HttpError;

#[derive(Debug)]
pub struct Response {
    status_code: u16,
    headers: Vec<(String, String)>,
    body: Option<(&'static str, Vec<u8>)>,
}

pub trait IntoBytes {
    fn into_bytes(self) -> Vec<u8>;
}

pub trait ContentType {
    fn content_type(&self) -> &'static str {
        "text/plain; charset=utf-8"
    }
}

pub trait IntoResponse {
    fn into_response(self) -> Response;
}

impl Response {
    pub fn new() -> Self {
        Self {
            status_code: 200,
            headers: Vec::new(),
            body: None,
        }
    }

    pub fn status_code(self, status_code: u16) -> Self {
        Self {
            status_code,
            ..self
        }
    }

    pub fn header(self, header: &str, value: &str) -> Self {
        let mut headers = self.headers;
        headers.push((header.into(), value.into()));
        Self { headers, ..self }
    }

    pub fn body(self, body: impl IntoBytes + ContentType) -> Self {
        let content_type = body.content_type();
        let body = body.into_bytes();
        Self {
            body: Some((content_type, body)),
            ..self
        }
    }

    pub fn ok(body: impl IntoBytes + ContentType) -> Self {
        Self::new().body(body)
    }

    pub fn created(body: impl IntoBytes + ContentType) -> Self {
        Self::new().status_code(201).body(body)
    }

    pub fn no_content() -> Self {
        Self::new().status_code(204)
    }

    pub fn bad_request(body: impl IntoBytes + ContentType) -> Self {
        Self::new().status_code(400).body(body)
    }

    pub fn unauthorized() -> Self {
        Self::new().status_code(401)
    }

    pub fn forbidden(body: impl IntoBytes + ContentType) -> Self {
        Self::new().status_code(403).body(body)
    }

    pub fn not_found(body: impl IntoBytes + ContentType) -> Self {
        Self::new().status_code(404).body(body)
    }

    pub fn internal_server_error(body: impl IntoBytes + ContentType) -> Self {
        Self::new().status_code(500).body(body)
    }

    pub fn into_bytes(self) -> Result<Vec<u8>, HttpError> {
        let mut s = String::new();

        s.push_str(&format!("HTTP/1.1 {}\r\n", self.status_code));

        for (header, value) in self.headers {
            s.push_str(&format!("{}: {}\r\n", header, value));
        }

        if let Some((content_type, body)) = self.body {
            s.push_str(&format!("Content-Type: {}\r\n", content_type));
            s.push_str(&format!("Content-Length: {}\r\n", body.len()));
            s.push_str("\r\n");
            s.push_str(
                &String::from_utf8(body)
                    .map_err(|_| HttpError::new(500, "Failed to parse response body"))?,
            );
        } else {
            s.push_str("\r\n");
        }

        Ok(s.into_bytes())
    }
}

impl IntoBytes for String {
    fn into_bytes(self) -> Vec<u8> {
        self.into()
    }
}

impl ContentType for String {}

impl IntoBytes for &str {
    fn into_bytes(self) -> Vec<u8> {
        self.into()
    }
}

impl ContentType for &str {}