zeke 0.1.6

a http library for rust built on top of tokio
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use std::time::Duration;
use std::sync::{Arc, PoisonError};

use tokio::sync::RwLock;
use tokio::{io::{AsyncReadExt, AsyncWriteExt}, net::{TcpListener, TcpStream}, time::timeout, sync::MutexGuard};

use crate::http::router::Router;
use crate::http::middleware::Middlewares;
use crate::http::response::{Response, ResponseBytes, PotentialResponse};
use crate::http::request::{Request, RequestBuffer};
use crate::http::handler::Handler;

pub async fn connect_socket(listener: &TcpListener, router: Arc<Router>) {
	let socket_result = listener.accept().await;
	if socket_result.is_err() {
		// TODO: log
		return;
	}
	let socket_result = socket_result.unwrap();
	let (socket, _addr) = socket_result;
	tokio::spawn(async move {
		let (socket, response) = handle_connection(socket, router).await;
		let response_bytes: ResponseBytes = response.to_bytes();
		let (mut socket, err_response) = write_socket(socket, &response_bytes).await;
		if err_response.is_some() {
			// TODO: log
		}
		let shutdown_result = socket.shutdown().await;
		if shutdown_result.is_err() {
			// TODO: log
		}
		return;
	});

}

pub async fn handle_connection(socket: TcpStream, router: Arc<Router>) -> (TcpStream, Response) {
    let (socket, request_bytes, potetial_response) = read_socket(socket).await;
	if potetial_response.is_some() {
		return (socket, potetial_response.unwrap());
	}
	if request_bytes.len() == 0 {
		// TODO: does it matter if we get any bytes?
		return (socket, Response::new().status(200));
	}
	let (request, potential_response) = Request::new_from_bytes(request_bytes);
	if potential_response.is_some() {
		return (socket, potential_response.unwrap());
	}
	let response: Response = handle_request(router, request).await;
	return (socket, response);
}

pub async fn handle_request(router: Arc<Router>, request: Request) -> Response {
    let route_handler = router.routes.get(request.method_and_path.as_str());
	if route_handler.is_none() {
		return Response::new()
			.status(404)
			.body("route not found");
	}
	let route_handler = route_handler.unwrap();
	let potential_route: Result<MutexGuard<(Handler, Middlewares, Middlewares)>, PoisonError<MutexGuard<(Handler, Middlewares, Middlewares)>>> = Ok(route_handler.lock().await); // TODO: need to handle this ok() better
	if potential_route.is_err() {
		return Response::new()
			.status(500)
			.body("failed to lock route handler")
	}
	let route_handler = potential_route.unwrap();
	let (handler, middlewares, outerwares) = &*route_handler;
	let (request, potential_response) = handle_middleware(request, middlewares).await;
	match potential_response {
		Some(response) => {
			return response;
		},
		None => {
			let handler = handler.func.read().await;
			let (request, handler_response) = handler(request).await;
			// TODO: clean all the white space up out of the handler_response?
			let (_, potential_response) = handle_middleware(request, outerwares).await;
			match potential_response {
				Some(response) => {
					return response;
				},
				None => {
					return handler_response;
				},
			}
		},
	}
}

pub async fn handle_middleware(mut request: Request, middlewares: &Middlewares) -> (Request, PotentialResponse) {
    if middlewares.len() == 0 {
        return (request, None);
    };
    for middleware in middlewares {
        let middleware = middleware.func.read().await;
        let potential_response = middleware(&mut request).await;
		if potential_response.is_none() {
			continue;
		}
		let response = potential_response.unwrap();
		return (request, Some(response));
    }
    return (request, None);
}

pub async fn read_socket(mut socket: TcpStream) -> (TcpStream, RequestBuffer, PotentialResponse) {
    let mut buffer: [u8; 1024] = [0; 1024];
    match timeout(Duration::from_secs(5), socket.read(&mut buffer)).await {
        Ok(Ok(bytes_read)) if bytes_read > 0 => {
            // TODO: trunacate() and keep only what was read?
            return (socket, buffer, None);
        },
        Ok(Ok(_)) => {
            // No data read, potentially a graceful close
            return (socket, buffer, Some(Response::new()
                .status(500)
                .body("no data received from client connection")
            ));
        },
        Ok(Err(e)) => {
            // Handle specific I/O errors if needed
            return (socket, buffer, Some(Response::new()
                .status(500)
                .body(&format!("failed to read from socket: {}", e))
            ));
        },
        Err(_) => {
            // Timeout
            return (socket, buffer, Some(Response::new()
                .status(408)
                .body("read timeout")
            ));
        },
    }
}

pub async fn write_socket(mut socket: TcpStream, response_bytes: &[u8]) -> (TcpStream, PotentialResponse) {
    match timeout(Duration::from_secs(5), socket.write_all(response_bytes)).await {
        Ok(Ok(_)) => {
            return (socket, None);
        },
        Ok(Err(e)) => {
            // TODO: set up logging
            return (socket, Some(Response::new()
                .status(500)
                .body(&format!("failed to write to socket: {}", e))
            ));
        },
        Err(_) => {
            // Timeout
            return (socket, Some(Response::new()
                .status(408)
                .body("write timeout")
            ));
        },
    }
}