choki 1.1.19

A simple http server built from scratch. Not intended for production uses but a simple website with some query stuff can be made. (can withstand a lot of requests per second)
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

use std::fs::{ self, File };
use std::io::{ BufReader, Read, Seek, SeekFrom, Write };

use choki::src::request::Request;
use choki::src::response::Response;
use choki::src::structs::{ ContentType, Header, HttpServerError, RequestType, ResponseCode, Url };
use choki::Server;

fn main() {
    let mut server: Server<u8> = Server::new(None, None);

    server.use_middleware(|url: &Url, req: &Request, res: &mut Response, public_var: &Option<u8>| {
        println!("Ip {}", req.ip.clone().unwrap_or_default());
        return true;
    });
    server.use_logger(|input: &choki::src::structs::HttpServerError| {
        println!("Hi custom error printer: {}", input.reason);
    });
    server
        .on(
            RequestType::Other("Custom".to_string()),
            "/",
            |req: Request, mut res: Response, public_var: Option<u8>| {
                res.send_string("HI custom one")
            }
        )
        .unwrap();

    server
        .get("/watch/[id]", |req: Request, mut res: Response, public_var: Option<u8>| {
            res.send_string("HI")
        })
        .unwrap();
    server
        .get("/test", |req: Request, mut res: Response, public_var: Option<u8>| {
            res.send_code(ResponseCode::Ok)
        })
        .unwrap();
    server
        .post("/filetest", |req: Request, mut res: Response, public_var: Option<u8>| {
            res.send_code(ResponseCode::Ok)?;
            let body: Vec<choki::src::structs::BodyItem<'_>> = req.body();
            Err(HttpServerError::new("Hi"))
        })
        .unwrap();
    server
        .get("/filetest", |mut req: Request, mut res: Response, public_var: Option<u8>| {
            res.send_code(ResponseCode::Ok)?;
            Err(HttpServerError::new("Opsi no!"))
        })
        .unwrap();

    server
        .get("/", |req: Request, mut res: Response, public_var: Option<u8>| {
            let mut file = File::open("./tests/static/index.html").unwrap();
            let size = file.metadata().unwrap().len();
            let mut buf_reader = BufReader::new(file);
            let mut data: Vec<u8> = Vec::new();
            buf_reader.read_to_end(&mut data).unwrap();
            res.send_bytes_chunked(&data, Some(ContentType::Html))?;

            Ok(())
        })
        .unwrap();
    server.new_static("/static", "./tests/static", false).unwrap();
    server.listen(3000, None, None, || { println!("Server is listening on port 3000") }).unwrap();
    Server::<i32>::lock();
}