grweb 0.1.2

A high-performance Rust Web framework based on gorust coroutine runtime
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

pub mod router;
pub mod middleware;
pub mod context;
pub mod server;
pub mod config;
pub mod static_files;
pub mod websocket;
pub mod pool;

pub use router::Router;
pub use middleware::{Middleware, MiddlewareChain};
pub use context::Context;
pub use server::Server;
pub use config::{AppConfig, ServerConfig, LoggingConfig, CorsConfig};
pub use websocket::{WebSocket, Message};
pub use pool::{ConnectionPool, SharedPool, PoolStats};

/// HTTP 方法枚举
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Method {
    GET,
    POST,
    PUT,
    DELETE,
    PATCH,
    HEAD,
    OPTIONS,
}

impl Method {
    pub fn as_str(&self) -> &'static str {
        match self {
            Method::GET => "GET",
            Method::POST => "POST",
            Method::PUT => "PUT",
            Method::DELETE => "DELETE",
            Method::PATCH => "PATCH",
            Method::HEAD => "HEAD",
            Method::OPTIONS => "OPTIONS",
        }
    }
}

/// HTTP 响应
#[derive(Debug)]
pub struct Response {
    pub status: u16,
    pub headers: Vec<(String, String)>,
    pub body: Vec<u8>,
}

impl Response {
    pub fn new(status: u16, body: impl Into<Vec<u8>>) -> Self {
        Self {
            status,
            headers: vec![
                ("Content-Type".to_string(), "text/plain;charset=utf-8".to_string()),
            ],
            body: body.into(),
        }
    }
    
    pub fn json(body: impl Into<Vec<u8>>) -> Self {
        let mut resp = Self::new(200, body);
        resp.headers = vec![("Content-Type".to_string(), "application/json".to_string())];
        resp
    }
    
    pub fn html(body: impl Into<Vec<u8>>) -> Self {
        let mut resp = Self::new(200, body);
        resp.headers = vec![("Content-Type".to_string(), "text/html".to_string())];
        resp
    }
    
    pub fn not_found() -> Self {
        Self::new(404, "404 Not Found")
    }
    
    pub fn internal_error() -> Self {
        Self::new(500, "500 Internal Server Error")
    }
}

impl From<&str> for Response {
    fn from(s: &str) -> Self {
        Response::html(s.to_string())
    }
}

impl From<String> for Response {
    fn from(s: String) -> Self {
        Response::html(s)
    }
}

impl From<Vec<u8>> for Response {
    fn from(data: Vec<u8>) -> Self {
        Response::new(200, data)
    }
}