first commit

Author: code-ga

.gitignore

@@ -0,0 +1,4 @@
+/target
+/Cargo.lock
+
+/dev/note/private

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "rust-http-web-lib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1.6.0"

README.md

@@ -0,0 +1 @@
+# sharhttp-rs

debug/.gitignore

@@ -0,0 +1,4 @@
+/target
+/Cargo.lock
+
+/dev/note/private

debug/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "debug"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rust-http-web-lib={path="../"}

debug/src/main.rs

@@ -0,0 +1,38 @@
+use rust_http_web_lib::routeManager::RouterManager;
+use rust_http_web_lib::App::HttpHandler;
+use rust_http_web_lib::Request::get_http_data::HeaderData;
+use rust_http_web_lib::Response::ResponseTool;
+
+use std::net::TcpListener;
+
+fn main() {
+    let mut handle = HttpHandler::new();
+    const PORT: i32 = 8000;
+
+    handle.get("/".to_owned(), home_handler);
+    handle.all(log_request);
+    let mut new_route = HttpHandler::new();
+    new_route.get("/".to_owned(), home_handler);
+
+    handle.route("/sub".to_string(), &new_route);
+    let listener = TcpListener::bind(format!("127.0.0.1:{PORT}"));
+    match listener {
+        Ok(listener) => {
+            println!(
+                "máy chủ bật rồi đó ở cổng {} link đi đến đó nè http://{}",
+                PORT,
+                listener.local_addr().unwrap()
+            );
+            handle.handle_http_request(listener);
+        }
+        Err(err) => {
+            panic!("{}", err);
+        }
+    }
+}
+fn home_handler(_request: &HeaderData, response: &mut ResponseTool, _: &mut RouterManager) {
+    response.send("<h1>hello world</h1>".to_string(), true);
+}
+fn log_request(request: &HeaderData, _response: &mut ResponseTool, _: &mut RouterManager) {
+    println!("method: {}, path: {}", request.method, request.path);
+}

src/App/mod.rs

@@ -0,0 +1,175 @@
+#![allow(dead_code)]
+use std::{collections::HashMap, net::TcpListener};
+
+use crate::{
+    routeManager::RouterManager, util::append_vec::append_vec, HandleConnection::RequestProcessing,
+    Request::get_http_data::HeaderData, Response::ResponseTool,
+};
+
+pub type HandleCallback = fn(&HeaderData, &mut ResponseTool, &mut RouterManager) -> (); // request: HeaderData, response: TcpStream
+pub type HandlerType = HashMap<HandlerHashmapKeyString, Vec<HandleCallback>>;
+#[derive(Clone)]
+pub struct HttpHandler {
+    handler: HandlerType,
+    not_found_handler: HandleCallback,
+    threading: bool,
+}
+
+pub fn default_not_found_handler(
+    _req: &HeaderData,
+    response: &mut ResponseTool,
+    _: &mut RouterManager,
+) {
+    let not_found_contents = "<h1>404 Page Not Found</h1>";
+    response.status(404);
+    response.send(not_found_contents.to_string(), true);
+}
+
+impl HttpHandler {
+    pub fn new() -> HttpHandler {
+        return HttpHandler {
+            handler: (HashMap::new()),
+            not_found_handler: default_not_found_handler,
+            threading: false,
+        };
+    }
+
+    pub fn turn_threading(&mut self) -> &mut Self {
+        self.threading = !self.threading;
+        self
+    }
+
+    pub fn post(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("POST".to_string(), path);
+        self.add_handle(key, handler);
+    }
+
+    pub fn get(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("GET".to_string(), path);
+        self.add_handle(key, handler);
+    }
+
+    pub fn put(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("PUT".to_owned(), path);
+        self.add_handle(key, handler);
+    }
+
+    pub fn patch(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("PATCH".to_string(), path);
+        self.add_handle(key, handler);
+    }
+    pub fn delete(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("DELETE".to_string(), path);
+        self.add_handle(key, handler);
+    }
+    pub fn all_method(&mut self, path: String, handler: HandleCallback) {
+        let key = get_key("*".to_string(), path);
+        self.add_handle(key, handler);
+    }
+    pub fn not_found(&mut self, handler: HandleCallback) {
+        self.not_found_handler = handler;
+    }
+    pub fn all(&mut self, handler: HandleCallback) {
+        let key = get_key("*".to_string(), "*".to_string());
+        self.add_handle(key, handler);
+    }
+    pub fn handle_http_request(&mut self, listener: TcpListener) {
+        for stream in listener.incoming() {
+            let mut stream = stream.unwrap();
+            let mut process = RequestProcessing::new(self.not_found_handler);
+            process.preProcessing(&self.handler, &mut stream);
+            if self.threading {
+                let han = &mut self.handler;
+                std::thread::spawn(move || process.processing(&mut stream))
+                    .join()
+                    .and_then(|f| {
+                        f.ProcessingRouter(han);
+                        Ok(())
+                    })
+                    .expect("đen thôi đỏ là red");
+            } else {
+                process
+                    .processing(&mut stream)
+                    .ProcessingRouter(&mut self.handler);
+            }
+            // stream
+            //     .shutdown(std::net::Shutdown::Both)
+            //     .expect("shutdown call failed");
+        }
+    }
+
+    pub fn handlers(&self) -> &HandlerType {
+        &self.handler
+    }
+    pub fn route(&mut self, path: String, route: &Self) {
+        self.add_route(path, route)
+    }
+}
+
+trait Handle {
+    fn add_handle(&mut self, key: HandlerHashmapKeyString, handler: HandleCallback);
+    fn add_multiple_handler(&mut self, key: HandlerHashmapKeyString, handler: Vec<HandleCallback>);
+}
+impl Handle for HttpHandler {
+    fn add_handle(&mut self, key: HandlerHashmapKeyString, handler: HandleCallback) {
+        self.add_multiple_handler(key, vec![handler])
+    }
+
+    fn add_multiple_handler(&mut self, key: HandlerHashmapKeyString, handler: Vec<HandleCallback>) {
+        pub_add_multiple_handler(&mut self.handler, key, handler);
+    }
+}
+
+pub fn pub_add_multiple_handler(
+    handlers: &mut HandlerType,
+    key: HandlerHashmapKeyString,
+    handler: Vec<HandleCallback>,
+) {
+    let handle = handlers.get_mut(&key);
+    match handle {
+        Some(handle) => append_vec(handle, &handler),
+        None => {
+            handlers.insert(key, handler);
+        }
+    }
+}
+pub fn get_key(method: String, path: String) -> HandlerHashmapKeyString {
+    let key = format!("{}{}", method, path);
+    return HandlerHashmapKeyString {
+        data: key,
+        method,
+        path,
+    };
+}
+#[derive(Clone, Eq, Hash, PartialEq)]
+pub struct HandlerHashmapKeyString {
+    pub data: String,
+    pub method: String,
+    pub path: String,
+}
+
+trait Router {
+    fn add_route(&mut self, path: String, route: &Self);
+}
+impl Router for HttpHandler {
+    fn add_route(&mut self, path: String, route: &Self) {
+        add_route_pub(&mut self.handler, path, route.handlers());
+    }
+}
+
+pub fn add_route_pub(hander: &mut HandlerType, path: String, route: &HandlerType) {
+    for n in route.keys() {
+        let mut new_path = path.clone();
+        new_path.push_str(
+            &(match new_path.ends_with("/") {
+                true => n.path.clone(),
+                false => match n.path.starts_with("/") {
+                    true => n.path.clone(),
+                    false => "/".to_owned() + &n.path,
+                },
+            }),
+        );
+        let key = get_key(n.method.clone(), new_path);
+        pub_add_multiple_handler(hander, key, route.get(n).unwrap().to_vec());
+    }
+}

src/HandleConnection/mod.rs

@@ -0,0 +1,118 @@
+#![allow(dead_code)]
+use std::{
+    collections::HashMap,
+    io::{BufRead, BufReader},
+    net::TcpStream,
+};
+
+use crate::{
+    routeManager::RouterManager,
+    util::append_vec::append_vec,
+    App::{get_key, HandlerType},
+    Request::get_http_data::{GetRequest, HeaderData},
+    Response::ResponseTool,
+};
+
+use crate::App::HandleCallback;
+
+pub struct RequestProcessing {
+    ProcessingHandler: Vec<HandleCallback>,
+    not_found_handler: HandleCallback,
+    httpData: HeaderData,
+}
+
+impl RequestProcessing {
+    pub fn new(not_found_handler: HandleCallback) -> RequestProcessing {
+        RequestProcessing {
+            ProcessingHandler: Vec::new(),
+            not_found_handler,
+            httpData: HeaderData::Default(),
+        }
+    }
+    pub fn preProcessing(&mut self, handlers: &HandlerType, stream: &mut TcpStream) {
+        self.get_request_data(stream);
+        self.get_handler(handlers);
+    }
+    pub fn processing(&mut self, stream: &mut TcpStream) -> RouterManager {
+        self.handle_connection(stream)
+    }
+}
+
+pub trait HandleConnection {
+    fn handle_connection(&mut self, stream: &mut TcpStream) -> RouterManager;
+    fn get_request_data(&mut self, stream: &TcpStream);
+    fn get_handler(&mut self, handlers: &HandlerType);
+}
+impl HandleConnection for RequestProcessing {
+    fn handle_connection(&mut self, stream: &mut TcpStream) -> RouterManager {
+        let mut response = ResponseTool {
+            stream,
+            response: false,
+            status: 200,
+            content: "".to_string(),
+            header: &mut HashMap::new(),
+            Request: self.httpData.clone(),
+            cookie: &mut Vec::new(),
+        };
+        let mut routerM = RouterManager::new();
+
+        routerM.setLocalPath(self.httpData.path.clone());
+        response.Setup();
+
+        if self.ProcessingHandler.len() <= 0 {
+            (self.not_found_handler)(&self.httpData, &mut response, &mut routerM);
+            return routerM;
+        };
+
+        for h in &self.ProcessingHandler {
+            if response.response {
+                return routerM;
+            }
+            (&h)(&self.httpData, &mut response, &mut routerM);
+        }
+        if response.response {
+            return routerM;
+        }
+        (self.not_found_handler)(&self.httpData, &mut response, &mut routerM);
+        return routerM;
+    }
+
+    fn get_request_data(&mut self, stream: &TcpStream) {
+        let http_request: Vec<_> = BufReader::new(stream.try_clone().unwrap())
+            .lines()
+            .map(|result| result.unwrap())
+            .take_while(|line| !line.is_empty())
+            .collect();
+        self.httpData = GetRequest(&http_request);
+    }
+
+    fn get_handler(&mut self, handlers: &HandlerType) {
+        let path_use = String::from(format!(
+            "{}",
+            format_args!(
+                "{}{}",
+                self.httpData.path.clone(),
+                match self.httpData.path.ends_with("/") {
+                    true => "*",
+                    false => "/*",
+                }
+            )
+        ));
+        let mut path_list: Vec<String> =
+            vec!["*".to_string(), path_use, self.httpData.path.clone()];
+        if !self.httpData.path.clone().ends_with("/") {
+            path_list.push(format!("{}/", self.httpData.path.clone()));
+        }
+
+        let method_list = vec!["*", &self.httpData.method];
+        for path in path_list {
+            for method in &method_list {
+                let key = get_key(method.to_string(), path.to_string());
+                if handlers.contains_key(&key) {
+                    let rest_handlers = handlers.get(&key).unwrap();
+                    append_vec(&mut self.ProcessingHandler, rest_handlers);
+                }
+            }
+        }
+    }
+}

src/Request/get_default_header.rs

@@ -0,0 +1,6 @@
+use super::get_http_data::HeaderType;
+
+
+pub fn default_header(header: &HeaderType) -> &HeaderType {
+    header
+}