Redesign classes, added default rewrite/simple folder, fixed #6

Author: sea5kg

.gitignore

@@ -1,4 +1,5 @@
 tmp/*
 wsjcpp-light-web-server
 .logs/*
-__pycache__
+__pycache__
+.vscode/*

CMakeLists.txt

@@ -15,13 +15,15 @@ list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_request.h")
 list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_request.cpp")
 list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_response.cpp")
 list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_response.h")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_deque_http_requests.h")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_deque_http_requests.cpp")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_handler_rewrite_folder.h")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_handler_rewrite_folder.cpp")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_handler_web_folder.h")
+list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_http_handler_web_folder.cpp")
 list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_server.h")
 list (APPEND WSJCPP_SOURCES "src/wsjcpp_light_web_server.cpp")
 
-## Http Handlers
-list (APPEND WSJCPP_SOURCES "src/http_handlers/http_handler_web_folder_example.h")
-list (APPEND WSJCPP_SOURCES "src/http_handlers/http_handler_web_folder_example.cpp")
-
 include_directories(${WSJCPP_INCLUDE_DIRS})
 
 add_executable (wsjcpp-light-web-server ${WSJCPP_SOURCES})

README.md

@@ -12,101 +12,159 @@ Just include this files:
 - src/wsjcpp_light_web_http_request.cpp
 - src/wsjcpp_light_web_http_response.h
 - src/wsjcpp_light_web_http_response.cpp
+- src/wsjcpp_light_web_http_handler_rewrite_folder.h
+- src/wsjcpp_light_web_http_handler_rewrite_folder.cpp
+- src/wsjcpp_light_web_http_handler_web_folder.h
+- src/wsjcpp_light_web_http_handler_web_folder.cpp
 - src/wsjcpp_light_web_server.h
 - src/wsjcpp_light_web_server.cpp
 
-
 ## Integrate via wsjcpp
 
 ```
 $ wsjcpp install https://github.com/wsjcpp/wsjcpp-light-web-server:master
 ```
 
-# Http Handlers examples
+## Examples
+
+### Example for simular rewrute_rules
+
+Simpular apache:
+```
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule . index.html
+```
+
+Contains base handler:
+```
+WSJCppLightWebHttpHandlerRewriteFolder(sPrefixPath, sDirPath)
+```
+Where
+* sPrefixPath - like "/app1/" -> "http://localhost:1234/app1/"
+* sDirPath - relative or absulte path to folder with web files
+
+Specific: if file will be not found in web folder so will be returned file index.html
+
+Will be good for single-web-app (like angular)
+
+Example init, add handler and start server
+```
+WSJCppLightWebServer httpServer;
+httpServer.setPort(1234);
+httpServer.setMaxWorkers(1);
+httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new WSJCppLightWebHttpHandlerRewriteFolder("/app1/", "./web"));
+httpServer.startSync(); // this method will be hold current thread, if you with you can call just start/stop command
+```
+
+After compile and start will be available on `http://localhost:1234/app1/`
+
+### Example simple web folder
+
+Contains base handler:
+```
+WSJCppLightWebHttpHandlerWebFolder(sPrefixPath, sDirPath)
+```
+
+Where
+* sPrefixPath - like "/app2/" -> "http://localhost:1234/app2/"
+* sDirPath - relative or absulte path to folder with web files
+
+Specific: if file does not exists wil be returned 404 not found
 
 Example init, add handler and start server
 ```
-LightHttpServer httpServer;
+WSJCppLightWebServer httpServer;
 httpServer.setPort(1234);
 httpServer.setMaxWorkers(1);
-httpServer.handlers()->add((WSJCppLightWebHttpHandlerBase *)new HttpHandlerWebFolderExample("./web"));
+httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new WSJCppLightWebHttpHandlerWebFolder("/app2/", "./web"));
 httpServer.startSync(); // this method will be hold current thread, if you with you can call just start/stop command
 ```
 
-## Web Folder example
+After compile and start will be available on `http://localhost:1234/app2/`
+
+### Example custom handler
 
 Define class:
 
+header-file:
 ```
+#ifndef HTTP_HANDLER_CUSTOM_H
+#define HTTP_HANDLER_CUSTOM_H
+
 #include <wsjcpp_light_web_server.h>
 
-class HttpHandlerWebFolderExample : WSJCppLightWebHttpHandlerBase {
+class HttpHandlerCustom : WSJCppLightWebHttpHandlerBase {
     public:
-        HttpHandlerWebFolderExample(const std::string &sWebFolder);
+        HttpHandlerCustom();
         virtual bool canHandle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest);
         virtual bool handle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest);
 
     private:
         std::string TAG;
-        std::string m_sWebFolder;
 };
+#endif // HTTP_HANDLER_CUSTOM_H
 ```
 
-Class implementation:
+source-file:
 ```
 #include <wsjcpp_core.h>
 
 // ----------------------------------------------------------------------
 
-HttpHandlerWebFolderExample::HttpHandlerWebFolderExample(const std::string &sWebFolder)
-    : WSJCppLightWebHttpHandlerBase("web-folder") {
+HttpHandlerCustom::HttpHandlerCustom()
+    : WSJCppLightWebHttpHandlerBase("custom") {
 
-    TAG = "HttpHandlerWebFolderExample";
-    m_sWebFolder = sWebFolder;
+    TAG = "HttpHandlerCustom";
 }
 
 // ----------------------------------------------------------------------
 
-bool HttpHandlerWebFolderExample::canHandle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest) {
+bool HttpHandlerCustom::canHandle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest) {
     std::string _tag = TAG + "-" + sWorkerId;
-    // WSJCppLog::warn(_tag, "canHandle: " + pRequest->requestPath());
-    std::string sRequestPath = pRequest->requestPath();
-    
-    if (sRequestPath == "") {
-        sRequestPath = "/";
-        WSJCppLog::warn(_tag, "Request path is empty");
-    }
+    std::string sRequestPath = pRequest->getRequestPath();
 
-    if (sRequestPath == "/") {
-        sRequestPath = "/index.html";
+    if (sRequestPath == "/custom/" || sRequestPath == "/custom") {
+        return true;    
     }
-
-    if (!WSJCppCore::dirExists(m_sWebFolder)) {
-        WSJCppLog::warn(_tag, "Directory " + m_sWebFolder + " does not exists");
+    if (sRequestPath == "/custom1/" || sRequestPath == "/custom1") {
+        return true;    
     }
-    return true;
+    return false;
 }
 
 // ----------------------------------------------------------------------
 
-bool HttpHandlerWebFolderExample::handle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest) {
+bool HttpHandlerCustom::handle(const std::string &sWorkerId, WSJCppLightWebHttpRequest *pRequest) {
     std::string _tag = TAG + "-" + sWorkerId;
-    std::string sRequestPath = pRequest->requestPath();
-    // WSJCppLog::warn(_tag, pRequest->requestPath());
+    std::string sRequestPath = pRequest->getRequestPath();
+    // WSJCppLog::warn(_tag, sRequestPath);
     
-    if (sRequestPath == "") {
-        sRequestPath = "/";
-    }
-    
-    std::string sFilePath = m_sWebFolder + sRequestPath; // TODO check /../ in path
-    if (WSJCppCore::fileExists(sFilePath)) {
-        WSJCppLightWebHttpResponse resp(pRequest->sockFd());
-        resp.cacheSec(60).ok().sendFile(sFilePath);
+    WSJCppLightWebHttpResponse resp(pRequest->sockFd());
+    if (sRequestPath == "/custom" || sRequestPath == "/custom/") {
+        resp.cacheSec(60).ok().sendText(
+            "<h1>This is custom</h1>"
+        );
+    } else if (sRequestPath == "/custom1" || sRequestPath == "/custom1/") {
+        resp.cacheSec(60).ok().sendText(
+            "<h1>But this is custom1</h1>"
+        );
     } else {
-        std::string sFilePath = m_sWebFolder + "/index.html";
-        WSJCppLightWebHttpResponse resp(pRequest->sockFd());
-        resp.cacheSec(60).ok().sendFile(sFilePath);    
+        resp.noCache().ok().sendText(
+            "<h1>Unknown</h1>"
+        );
     }
     return true;
 }
-```
+```
+
+Example init, add handler and start server
+__order is important! Server will call canHandle & handle in same order as addHandler called__
+```
+WSJCppLightWebServer httpServer;
+httpServer.setPort(1234);
+httpServer.setMaxWorkers(1);
+httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new HttpHandlerCustom());
+httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new WSJCppLightWebHttpHandlerRewriteFolder("/", "./web"));
+httpServer.startSync(); // this method will be hold current thread, if you with you can call just start/stop command
+```

server-tests/run_tests.py

@@ -9,8 +9,7 @@
 
 try:
     print(" > > > TESTS: begin ")
-    liblightwebservertest.start_server("../", ["./wsjcpp-light-web-server", "start"], 1234)
-
+    liblightwebservertest.start_server("../", ["./wsjcpp-light-web-server", "folder", "./web"], 1234)
     print("index.html - testing...")
     index_html = open("../web/index.html", 'r').read()
     r = requests.get(TEST_URL)
@@ -44,7 +43,11 @@
         else:
             print("index.css - ok")
 
-    
+    print("not-found - testing...")
+    r = requests.get(TEST_URL + "/not-found 0101")
+    if r.status_code != 404:
+        raise Exception("not-found - Wrong status code expected 404, but got " + str(r.status_code))
+    print("index.css - ok")
 
 finally:
     liblightwebservertest.stop_server()

src/http_handlers/http_handler_web_folder_example.h

@@ -1,9 +1,7 @@
-#include <string.h>
-#include <iostream>
-#include <algorithm>
 #include <wsjcpp_core.h>
 #include <wsjcpp_light_web_server.h>
-#include "http_handlers/http_handler_web_folder_example.h"
+#include "wsjcpp_light_web_http_handler_rewrite_folder.h"
+#include "wsjcpp_light_web_http_handler_web_folder.h"
 
 int main(int argc, const char* argv[]) {
     std::string TAG = "MAIN";
@@ -15,11 +13,26 @@ int main(int argc, const char* argv[]) {
     WSJCppLog::setPrefixLogFile("wsjcpp");
     WSJCppLog::setLogDirectory(".logs");
 
+    if (argc != 3) {
+        std::cout << "Usage: " << argv[0] << " [folder|rewrite] <dir>" << std::endl;
+        return -1;
+    }
+    std::string sType = std::string(argv[1]);
+    if (sType != "folder" && sType != "rewrite") {
+        std::cout << "Usage: " << argv[0] << " [folder|rewrite] <dir>" << std::endl;
+        return -1;
+    }
+
+    std::string sDir = std::string(argv[2]);
+
     WSJCppLightWebServer httpServer;
     httpServer.setPort(1234);
     httpServer.setMaxWorkers(1);
-    httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new HttpHandlerWebFolderExample("./web"));
-
+    if (sType == "folder") {
+        httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new WSJCppLightWebHttpHandlerWebFolder("/", sDir));
+    } else if (sType == "rewrite") {
+        httpServer.addHandler((WSJCppLightWebHttpHandlerBase *)new WSJCppLightWebHttpHandlerRewriteFolder("/", sDir));
+    }
     httpServer.startSync();
     return 0;
 }

src/main.cpp

@@ -0,0 +1,52 @@
+#include "wsjcpp_light_web_deque_http_requests.h"
+
+#include <wsjcpp_core.h>
+
+// ----------------------------------------------------------------------
+// WSJCppLightWebDequeHttpRequests
+
+WSJCppLightWebDequeHttpRequests::WSJCppLightWebDequeHttpRequests() {
+    TAG = "WSJCppLightWebDequeHttpRequests";
+}
+
+// ----------------------------------------------------------------------
+
+WSJCppLightWebHttpRequest *WSJCppLightWebDequeHttpRequests::popRequest() {
+    if (m_dequeRequests.size() == 0) {
+        m_mtxWaiterRequests.lock();
+    }
+    std::lock_guard<std::mutex> guard(this->m_mtxDequeRequests);
+    WSJCppLightWebHttpRequest *pRequest = nullptr;
+    int nSize = m_dequeRequests.size();
+    if (nSize > 0) {
+        pRequest = m_dequeRequests.back();
+        m_dequeRequests.pop_back();
+    }
+    return pRequest;
+}
+
+// ----------------------------------------------------------------------
+
+void WSJCppLightWebDequeHttpRequests::pushRequest(WSJCppLightWebHttpRequest *pRequest) {
+    {
+        std::lock_guard<std::mutex> guard(this->m_mtxDequeRequests);
+        if (m_dequeRequests.size() > 20) {
+            WSJCppLog::warn(TAG, " deque more than " + std::to_string(m_dequeRequests.size()));
+        }
+        m_dequeRequests.push_front(pRequest);
+    }
+    
+    if (m_dequeRequests.size() == 1) {
+        m_mtxWaiterRequests.unlock();   
+    }
+}
+
+// ----------------------------------------------------------------------
+
+void WSJCppLightWebDequeHttpRequests::cleanup() {
+    std::lock_guard<std::mutex> guard(this->m_mtxDequeRequests);
+    while (m_dequeRequests.size() > 0) {
+        delete m_dequeRequests.back();
+        m_dequeRequests.pop_back();
+    }
+}

src/wsjcpp_light_web_deque_http_requests.cpp

@@ -0,0 +1,29 @@
+#ifndef WSJCPP_LIGHT_WEB_DEQUE_HTTP_REQUESTS_H
+#define WSJCPP_LIGHT_WEB_DEQUE_HTTP_REQUESTS_H
+
+#include <string>
+#include <deque>
+#include <mutex>
+
+#include "wsjcpp_light_web_http_request.h"
+
+// ---------------------------------------------------------------------
+
+class WSJCppLightWebDequeHttpRequests {
+    public:
+        WSJCppLightWebDequeHttpRequests();
+        WSJCppLightWebHttpRequest *popRequest();
+        void pushRequest(WSJCppLightWebHttpRequest *pRequest);
+        void cleanup();
+
+    private:
+        std::string TAG;
+
+        std::mutex m_mtxDequeRequests;
+        std::mutex m_mtxWaiterRequests;
+        std::deque<WSJCppLightWebHttpRequest *> m_dequeRequests;
+};
+
+#endif // WSJCPP_LIGHT_WEB_DEQUE_HTTP_REQUESTS_H
+
+