lact/connection/
connection.rs

1use async_std::{io::ReadExt, net::TcpStream};
2use futures::AsyncWriteExt;
3
4use crate::{Request, Response, Server, StatusCode};
5
6pub async fn connect(
7    server: &mut Server,
8    mut stream: TcpStream,
9) {
10    let mut buffer = [0; 1024];
11
12    while match stream.read(&mut buffer).await {
13        Ok(0) => {
14            match stream.close().await {
15                Ok(size) => size,
16                Err(error) => panic!("Error during stream write: {:?}.", error),
17            };
18            false
19        }
20        Ok(_) => {
21            let mut req = Request::new(&buffer);
22            let mut res = Response::new(&stream);
23            let (route, params, query) = server.router_manager.get_route(&req.method, &req.uri);
24
25            match route {
26                Some(route) => {
27                    let mut middleware_error_status_code: Option<StatusCode> = None;
28                    req.params = params;
29                    req.query = query;
30                    res.uri = req.uri.clone();
31
32                    for middleware in &server.middleware{
33                      match middleware(&req, &mut res){
34                        Ok(_) => (),
35                        Err(status_code) => {
36                          middleware_error_status_code = Some(status_code);
37                          break;
38                        },
39                      }
40                    }
41
42                    match middleware_error_status_code {
43                        Some(status_code) => res.send_status(status_code).await,
44                        None => {
45                          let mut handler = route.handler.lock().await;
46                          handler.call(req, res).await;
47                          buffer = [0; 1024];
48                        },
49                    }
50                }
51                None => res.send_status(StatusCode::NotFound).await,
52            };
53
54            true
55        }
56        Err(error) => panic!("Error during stream read: {:?}.", error),
57    } {}
58}