mini 0.0.4

Dependency-free extension to the standard library
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
127

/*
 * TODO: use a proper URL parser.
 * TODO: do proper HTTP protocol handling.
 */

use std::fmt::{self, Display, Formatter};
use std::io;
use std::net;

use crate::aio::handler::{Loop, Stream};
use crate::aio::net::{
    ListenerMsg,
    TcpConnection,
    TcpConnectionNotify,
    TcpListenNotify,
};
use crate::aio::net::TcpListener;

struct Listener<HANDLER> {
    handler: HANDLER,
}

impl<HANDLER> Listener<HANDLER> {
    fn new(handler: HANDLER) -> Self {
        Self {
            handler,
        }
    }
}

impl<HANDLER: HttpHandler + 'static> TcpListenNotify for Listener<HANDLER> {
    fn listening(&mut self, listener: &net::TcpListener) {
        if let Err(error) = listener.local_addr() {
            eprintln!("Could not get local address: {}.", error);
        }
    }

    fn not_listening(&mut self) {
        eprintln!("Could not listen.");
    }

    fn connected(&mut self, _listener: &net::TcpListener) -> Box<dyn TcpConnectionNotify> {
        Box::new(Server::new(self.handler.clone()))
    }
}

struct Server<HANDLER> {
    handler: HANDLER,
}

impl<HANDLER: HttpHandler> Server<HANDLER> {
    fn new(handler: HANDLER) -> Self {
        Self {
            handler,
        }
    }
}

impl<HANDLER: HttpHandler> TcpConnectionNotify for Server<HANDLER> {
    fn accepted(&mut self, _connection: &mut TcpConnection) {
    }

    fn received(&mut self, connection: &mut TcpConnection, data: Vec<u8>) {
        let request = String::from_utf8(data).unwrap_or_else(|_| String::new());
        let mut lines = request.lines();
        let first_line = lines.next().unwrap_or("GET");
        let mut parts = first_line.split_whitespace();
        let method = parts.next().unwrap_or("GET");
        let url = parts.next().unwrap_or("/");
        let mut url_parts = url.split('?');
        let request = Request {
            method: Method::from_str(method),
            path: url_parts.next().unwrap_or("/").to_string(),
            query_string: url_parts.next().unwrap_or("").to_string(),
        };
        let content = self.handler.request(&request);
        let len = content.len();
        let response = format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: text/html\r\n\r\n{}", len, content);
        let _ = connection.write(response.into_bytes()); // TODO: handle errors.
    }

    fn closed(&mut self, _connection: &mut TcpConnection) {
    }
}

#[derive(PartialEq)]
pub enum Method {
    Get,
    Post,
}

impl Method {
    pub fn from_str(method: &str) -> Method {
        match method {
            "POST" => Method::Post,
            "GET" | _ => Method::Get,
        }
    }
}

impl Display for Method {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        let method =
            match *self {
                Method::Get => "GET",
                Method::Post => "POST",
            };
        write!(formatter, "{}", method)
    }
}

pub struct Request {
    pub method: Method,
    pub path: String,
    pub query_string: String,
}

pub trait HttpHandler: Clone {
    fn request(&mut self, request: &Request) -> String;
}

pub fn serve<HANDLER>(event_loop: &mut Loop, addr: &str, handler: HANDLER) -> io::Result<Stream<ListenerMsg>>
where HANDLER: HttpHandler + 'static,
{
    TcpListener::ip4(event_loop, addr, Listener::new(handler))
        .map(|(stream, _addr)| stream)
}