lil_http 0.1.2

A simple web framework with no external dependencies
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

use crate::{http::Request, router::Router};
use anyhow::Result;
use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    net::{TcpListener, TcpStream},
};

/// The server is responsible for accepting connections and routing requests.
///
/// # Example
///
/// ```rust,no_run
/// use lil_http::{Server, Response};
///
/// #[tokio::main]
/// async fn main() {
///    let mut http = Server::new().await.unwrap();
///
///    http.routes
///        .get("/", |request| {
///           println!("Received {} request to {}", request.method, request.path);
///
///          Response::text("Hello, World!")
///       });
///
///    http.run().await;
/// }
/// ```
///
/// # Notes
///
/// The server will not stop until the process is killed.
pub struct Server {
    /// The underlying TCP listener.
    listener: TcpListener,
    /// The router instance that will handle requests.
    pub routes: Router,
}

impl Server {
    /// # Errors
    ///
    /// Will return an error if port 3000 is already in use.
    pub async fn new() -> Result<Self> {
        Self::with_port("3000").await
    }

    /// # Errors
    ///
    /// Will return an error if the port is already in use.
    pub async fn with_port(port: &str) -> Result<Self> {
        let listener = TcpListener::bind(format!("0.0.0.0:{port}")).await?;
        println!("Server listening on port {port}");

        Ok(Self {
            listener,
            routes: Router::new(),
        })
    }

    /// # Panics
    ///
    /// Will panic if the server fails to accept a connection.
    pub async fn run(&self) {
        loop {
            let incoming = self.listener.accept().await;

            match incoming {
                Ok((mut stream, _)) => {
                    let router = self.routes.clone();

                    tokio::spawn(async move {
                        Self::handle_connection(&mut stream, router).await.unwrap();
                    });
                }
                Err(e) => {
                    println!("error: {e}");
                }
            }
        }
    }

    async fn handle_connection(stream: &mut TcpStream, router: Router) -> Result<()> {
        loop {
            let mut buf = [0; 1024];
            _ = stream.read(&mut buf).await?;
            let Ok(request) = Request::try_from(&buf) else { break };

            let response = router.handle(request);

            stream.write_all(response.to_string().as_bytes()).await?;
            stream.shutdown().await?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use serial_test::serial;

    use super::*;

    #[tokio::test]
    #[serial]
    async fn test_can_create_server() {
        let _ = Server::new().await.unwrap();
    }

    #[tokio::test]
    #[serial]
    async fn test_can_create_server_with_port() {
        let _ = Server::with_port("3001").await.unwrap();
    }

    #[tokio::test]
    #[serial]
    async fn test_can_run_server() {
        let http = Server::with_port("4012").await.unwrap();

        tokio::spawn(async move {
            http.run().await;
        });

        let _ = TcpStream::connect("127.0.0.1:4012").await.unwrap();
    }
}