Feature/v0.3 (#13)

* Add keep-alive support

* improved response returns

* Squashed commit of the following:

commit df77476
Author: Alberto Ruiz <[email protected]>
Date:   Thu Oct 31 12:54:46 2024 +0100

    update readme

commit 765cb63
Author: Alberto Ruiz <[email protected]>
Date:   Tue Oct 29 12:56:02 2024 +0100

    add load balancer to threads

commit f179c7d
Author: Alberto Ruiz <[email protected]>
Date:   Fri Oct 25 17:44:37 2024 +0200

    add request to worker queue early

    ROAD TO 100K

commit ed838da
Author: Alberto Ruiz <[email protected]>
Date:   Fri Oct 11 17:23:27 2024 +0200

    minor improvements

commit d9577bb
Author: Alberto Ruiz <[email protected]>
Date:   Thu Oct 10 12:05:39 2024 +0200

    fix poc 1

commit 58e653b
Author: Alberto Ruiz <[email protected]>
Date:   Thu Oct 10 12:01:07 2024 +0200

    poc 1

* v0.3

- Major refactor
- cache has its own module
- brew improvements (this will be replaced by hteacup)

Author: Az107

Cargo.lock

@@ -1,11 +1,7 @@
 [package]
 name = "hteapot"
-version = "0.2.6"
-exclude = [
-  "hteapot.toml",
-  "public/",
-  "readme.md"
-]
+version = "0.3.0"
+exclude = ["hteapot.toml", "public/", "readme.md"]
 license = "MIT"
 keywords = ["HTTP", "HTTP-SERVER"]
 description = "HTeaPot is a lightweight HTTP server library designed to be easy to use and extend."
@@ -17,9 +13,7 @@ authors = ["Alb Ruiz G. <[email protected]>"]
 
 [lib]
 name = "hteapot"
-path = "src/hteapot.rs"
+path = "src/hteapot/mod.rs"
 
 [[bin]]
 name = "hteapot"
-
-

Cargo.toml

@@ -1,11 +1,12 @@
 [HTEAPOT]
 port = 8081
 host = "0.0.0.0"
+threads = 4
 root = "public"
-threads = 5
 cache = true
-cache_ttl = 3600
+cache_ttl = 36
 [proxy]
 "/test" = "http://example.com"
 "/google" = "http://google.com"
+"/myip" = "http://ifconfig.co"
 # "/" = "http://ifconfig.co" # this will override all the proxys and local request

config.toml

@@ -2,7 +2,9 @@
 
 [Spanish](docs/readme-es.md) | English
 
-HteaPot is a simple HTTP server written in Rust. It allows you to serve static files and handle basic HTTP requests.
+HteaPot is a simple HTTP server written in Rust. It allows you to serve static files and handle
+HTTP requests.
+It´s also a library to write http applictions like an api
 
 # Features
 
@@ -33,13 +35,33 @@ You can configure the server using a TOML file. Here's an example configuration:
 ```toml
 [HTEAPOT]
 port = 8081 # The port on which the server will listen for incoming connections.
-host = "localhost" # The host address to bind the server to. 
+host = "localhost" # The host address to bind the server to.
 root = "public" # The root directory from which to serve files.
 ```
+
+# Library use
+
+For use hteapot as a library in rust
+ 1. Install the library
+ ```bash
+ $ cargo add hteapot
+ ```
+
+ 2. Then you can use it in your project
+```Rust
+use hteapot::{HttpStatus, Hteapot};
+
+fn main() {
+    let server = Hteapot::new("localhost", 8081);
+     teapot.listen(move|req| {
+}
+```
+
+
 # Contributing
 
 Contributions are welcome! Feel free to open issues or submit pull requests.
 
 # License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+This project is licensed under the MIT License - see the LICENSE file for details.

readme.md

@@ -6,6 +6,7 @@ use std::{
     net::TcpStream,
 };
 
+#[derive(Debug)]
 struct Url {
     scheme: String,
     domain: String,
@@ -27,7 +28,11 @@ fn parse_url(url: &str) -> Result<Url, &str> {
             _ => "80",
         }
     };
-    let (domain, path) = domain_path.split_once('/').unwrap();
+    let (domain, path) = match domain_path.split_once('/') {
+        Some((a, b)) => (a, b),
+        None => (domain_path, ""),
+    };
+
     Ok(Url {
         scheme: prefix.to_string(),
         domain: domain.to_string(),
@@ -51,21 +56,19 @@ pub fn fetch(url: &str) -> Result<Vec<u8>, &str> {
         return Err("Error fetching");
     }
     let mut client = client.unwrap();
-    let http_request = format!("GET /{} HTTP/1.1\r\nHost: {}\r\n\r\n", url.path, url.domain);
+    let http_request = format!(
+        "GET /{} HTTP/1.1\nHost: {}\nConnection: Close\n\n",
+        url.path, url.domain
+    );
     client.write(http_request.as_bytes()).unwrap();
+    let _ = client.flush();
     let mut full_buffer: Vec<u8> = Vec::new();
     let mut buffer = [0; 1024];
     loop {
         match client.read(&mut buffer) {
             Ok(0) => break,
-            Ok(n) => {
-                if n == 0 {
-                    break;
-                }
+            Ok(_n) => {
                 full_buffer.extend(buffer.iter().cloned());
-                if buffer.last().unwrap() == &0 {
-                    break;
-                }
             }
             Err(_) => break,
         }

src/brew.rs

@@ -0,0 +1,59 @@
+// Written by Alberto Ruiz, 2024-11-05
+// Config module: handles application configuration setup and parsing.
+// This module defines structs and functions to load and validate
+// configuration settings from files, environment variables, or other sources.
+use std::collections::HashMap;
+use std::time;
+use std::time::SystemTime;
+
+pub struct Cache {
+    //TODO: consider make it generic
+    data: HashMap<String, (Vec<u8>, u64)>,
+    max_ttl: u64,
+}
+
+impl Cache {
+    pub fn new(max_ttl: u64) -> Self {
+        Cache {
+            data: HashMap::new(),
+            max_ttl,
+        }
+    }
+
+    fn validate_ttl(&self, ttl: u64) -> bool {
+        let now = SystemTime::now();
+        let since_epoch = now
+            .duration_since(time::UNIX_EPOCH)
+            .expect("Time went backwards");
+        let secs = since_epoch.as_secs();
+        secs < ttl
+    }
+
+    fn get_ttl(&self) -> u64 {
+        let now = SystemTime::now();
+        let since_epoch = now
+            .duration_since(time::UNIX_EPOCH)
+            .expect("Time went backwards");
+        let secs = since_epoch.as_secs();
+        secs + self.max_ttl
+    }
+
+    pub fn set(&mut self, key: String, data: Vec<u8>) {
+        self.data.insert(key, (data, self.get_ttl()));
+    }
+
+    pub fn get(&mut self, key: String) -> Option<Vec<u8>> {
+        let r = self.data.get(&key);
+        if r.is_some() {
+            let (data, ttl) = r.unwrap();
+            if self.validate_ttl(*ttl) {
+                Some(data.clone())
+            } else {
+                self.data.remove(&key);
+                None
+            }
+        } else {
+            None
+        }
+    }
+}

src/cache.rs

@@ -96,12 +96,13 @@ pub fn toml_parser(content: &str) -> HashMap<String, TOMLSchema> {
     map
 }
 
+#[derive(Debug)]
 pub struct Config {
     pub port: u16,    // Port number to listen
     pub host: String, // Host name or IP
     pub root: String, // Root directory to serve files
     pub cache: bool,
-    pub cache_ttl: u64,
+    pub cache_ttl: u16,
     pub threads: u16,
     pub index: String, // Index file to serve by default
     //pub error: String, // Error file to serve when a file is not found

src/config.rs

@@ -0,0 +1,50 @@
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub enum HttpMethod {
+    GET,
+    POST,
+    PUT,
+    DELETE,
+    PATCH,
+    HEAD,
+    OPTIONS,
+    TRACE,
+    CONNECT,
+    Other(String),
+}
+
+impl HttpMethod {
+    pub fn from_str(method: &str) -> HttpMethod {
+        match method {
+            "GET" => HttpMethod::GET,
+            "POST" => HttpMethod::POST,
+            "PUT" => HttpMethod::PUT,
+            "DELETE" => HttpMethod::DELETE,
+            "PATCH" => HttpMethod::PATCH,
+            "HEAD" => HttpMethod::HEAD,
+            "OPTIONS" => HttpMethod::OPTIONS,
+            "TRACE" => HttpMethod::TRACE,
+            "CONNECT" => HttpMethod::CONNECT,
+            _ => Self::Other(method.to_string()),
+        }
+    }
+    pub fn to_str(&self) -> &str {
+        match self {
+            HttpMethod::GET => "GET",
+            HttpMethod::POST => "POST",
+            HttpMethod::PUT => "PUT",
+            HttpMethod::DELETE => "DELETE",
+            HttpMethod::PATCH => "PATCH",
+            HttpMethod::HEAD => "HEAD",
+            HttpMethod::OPTIONS => "OPTIONS",
+            HttpMethod::TRACE => "TRACE",
+            HttpMethod::CONNECT => "CONNECT",
+            HttpMethod::Other(method) => method.as_str(),
+        }
+    }
+}
+
+// #[derive(Clone, Copy)]
+// pub enum Protocol {
+//     HTTP,
+//     HTTPS,
+// }